home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / ODBCINF.PAK / DRVINFO.CPP < prev    next >
C/C++ Source or Header  |  1997-05-06  |  105KB  |  3,721 lines
  1. // DrvInfo.cpp : implementation file
  2. //
  3.  
  4. // This is a part of the Microsoft Foundation Classes C++ library.
  5. // Copyright (C) 1992-1996 Microsoft Corporation
  6. // All rights reserved.
  7. //
  8. // This source code is only intended as a supplement to the
  9. // Microsoft Foundation Classes Reference and related
  10. // electronic documentation provided with the library.
  11. // See these sources for detailed information regarding the
  12. // Microsoft Foundation Classes product.
  13.  
  14. #include "stdafx.h"
  15. #include "OdbcInfo.h"
  16. #include "catsets.h"
  17. #include "DrvInfo.h"
  18.  
  19. #ifdef _DEBUG
  20. #define new DEBUG_NEW
  21. #undef THIS_FILE
  22. static char THIS_FILE[] = __FILE__;
  23. #endif
  24.  
  25. /////////////////////////////////////////////////////////////////////////////
  26. // CMyPage property page - base class for all other pages
  27.  
  28. // static members
  29.  
  30. CDatabase* CMyPage::m_pDatabase = 0;
  31. CImageList* CMyPage::m_pImageList = 0;
  32. int CMyPage::m_nClients = 0;
  33.  
  34. // SQLGetInfo helpers
  35. //
  36. CString CMyPage::SQLGetInfoString(UWORD fInfoType)
  37. {
  38.     UCHAR    buffer[200];
  39.     SWORD    cbData;
  40.  
  41.     ::SQLGetInfo(m_pDatabase->m_hdbc,fInfoType,
  42.         (PTR)buffer,200,&cbData);
  43.     return CString(buffer);
  44. }
  45.  
  46. UWORD CMyPage::SQLGetInfoShort(UWORD fInfoType)
  47. {
  48.     UWORD    value;
  49.     SWORD    cbData;
  50.  
  51.     ::SQLGetInfo(m_pDatabase->m_hdbc,fInfoType,
  52.         (PTR)&value,2,&cbData);
  53.     return value;
  54. }
  55.  
  56. UDWORD CMyPage::SQLGetInfoLong(UWORD fInfoType)
  57. {
  58.     UDWORD    value;
  59.     SWORD    cbData;
  60.  
  61.     ::SQLGetInfo(m_pDatabase->m_hdbc,fInfoType,
  62.         (PTR)&value,4,&cbData);
  63.     return value;
  64. }
  65.  
  66. // formatting helpers
  67. //
  68. void CMyPage::ZeroIsNoneLong(CString& string,UWORD fInfoType)
  69. {
  70.     UDWORD value = SQLGetInfoLong(fInfoType);
  71.     if (value)
  72.         string.Format(_T("%d"),value);
  73.     else
  74.         string = _T("<none>");
  75. }
  76.  
  77. void CMyPage::ZeroIsNoneShort(CString& string,UWORD fInfoType)
  78. {
  79.     UWORD value = SQLGetInfoShort(fInfoType);
  80.     if (value)
  81.         string.Format(_T("%d"),value);
  82.     else
  83.         string = _T("<none>");
  84. }
  85.  
  86. void CMyPage::YIsYes(CString& string,UWORD fInfoType)
  87. {
  88.     string = SQLGetInfoString(fInfoType);
  89.     if (string == _T("Y"))
  90.         string = _T("Yes");
  91.     else if (string == _T("N"))
  92.         string = _T("No");
  93. }
  94.  
  95. void CMyPage::YIsSupported(CString& string,UWORD fInfoType)
  96. {
  97.     string = SQLGetInfoString(fInfoType);
  98.     if (string == _T("Y"))
  99.         string = _T("Supported");
  100.     else if (string == _T("N"))
  101.         string = _T("Not Supported");
  102. }
  103.  
  104. // CMyPage construction and destruction
  105.  
  106. CMyPage::CMyPage(CDatabase* pDatabase, UINT nIdTemplate)
  107.     : CPropertyPage(nIdTemplate)
  108. {
  109.     // if no other page has set the database, set it
  110.     if (!m_pDatabase)
  111.         m_pDatabase = pDatabase;
  112.  
  113.     // if no other page has created the image list, create it
  114.     if (!m_pImageList)
  115.     {
  116.         m_pImageList = new CImageList;
  117.         m_pImageList->Create(IDB_IMAGELIST,16,0,RGB(255,255,255));
  118.     }
  119.     m_nClients++;
  120. }
  121.  
  122. CMyPage::~CMyPage()
  123. {
  124.     // decrement imagelist client count, delete if it becomes 0
  125.     m_nClients--;
  126.     if (!m_nClients)
  127.         delete m_pImageList;
  128. }
  129.  
  130. /////////////////////////////////////////////////////////////////////////////
  131. // CDriverInfo property page
  132.  
  133. IMPLEMENT_DYNCREATE(CDriverInfo, CPropertyPage)
  134.  
  135. CDriverInfo::CDriverInfo(CDatabase* pDatabase)
  136.  : CMyPage(pDatabase,CDriverInfo::IDD)
  137. {
  138.     //{{AFX_DATA_INIT(CDriverInfo)
  139.     m_strSqlUserName = _T("");
  140.     m_strSqlServerName = _T("");
  141.     m_strSqlDbmsName = _T("");
  142.     m_strSqlDbmsVer = _T("");
  143.     m_strSqlDriverName = _T("");
  144.     m_strSqlDriverOdbcVer = _T("");
  145.     m_strSqlDriverVer = _T("");
  146.     m_strSqlOdbcVer = _T("");
  147.     m_strSqlOdbcApiConformance = _T("");
  148.     m_strSqlOdbcSagCliConformance = _T("");
  149.     m_strSqlOdbcSqlConformance = _T("");
  150.     m_strSqlOdbcSqlOptIef = _T("");
  151.     m_strSqlActiveConnections = _T("");
  152.     m_strSqlActiveStatements = _T("");
  153.     m_strSqlMultResultSets = _T("");
  154.     m_strSqlFileUsage = _T("");
  155.     m_strSqlDataSourceReadOnly = _T("");
  156.     m_strSqlDataSourceName = _T("");
  157.     m_strSqlAccessibleProcedures = _T("");
  158.     m_strSqlAccessibleTables = _T("");
  159.     m_strSqlDatabaseName = _T("");
  160.     //}}AFX_DATA_INIT
  161.  
  162.     OnNewDSN();
  163. }
  164.  
  165. CDriverInfo::~CDriverInfo()
  166. {
  167. }
  168.  
  169. void CDriverInfo::DumpToFile(CStdioFile& file)
  170. {
  171.     if (m_pDatabase->IsOpen())
  172.     {
  173.         CString    string;
  174.         file.WriteString(_T("Driver Info\n-----------\n"));
  175.         string.Format(_T("     Data Source Name - %s\n"),m_strSqlDataSourceName);
  176.         file.WriteString(string);
  177.         string.Format(_T("        Database Name - %s\n"),m_strSqlDatabaseName);
  178.         file.WriteString(string);
  179.         string.Format(_T("            User Name - %s\n"),m_strSqlUserName);
  180.         file.WriteString(string);
  181.         string.Format(_T("          Server Name - %s\n"),m_strSqlServerName);
  182.         file.WriteString(string);
  183.         string.Format(_T("                 DBMS - %s version %s\n"),
  184.             m_strSqlDbmsName,m_strSqlDbmsVer);
  185.         file.WriteString(string);
  186.         string.Format(_T("               Driver - %s version %s\n"),
  187.             m_strSqlDriverName,m_strSqlDriverVer);
  188.         file.WriteString(string);
  189.         string.Format(_T("     Driver ODBC Ver. - %s\n"),m_strSqlDriverOdbcVer);
  190.         file.WriteString(string);
  191.         string.Format(_T("         ODBC Version - %s\n"),m_strSqlOdbcVer);
  192.         file.WriteString(string);
  193.         string.Format(_T("      API Conformance - %s\n"),m_strSqlOdbcApiConformance);
  194.         file.WriteString(string);
  195.         string.Format(_T("      SQL Conformance - %s\n"),m_strSqlOdbcSqlConformance);
  196.         file.WriteString(string);
  197.         string.Format(_T("  SAG CLI Conformance - %s\n"),m_strSqlOdbcSagCliConformance);
  198.         file.WriteString(string);
  199.         string.Format(_T("     Optional SQL IEF - %s\n"),m_strSqlOdbcSqlOptIef);
  200.         file.WriteString(string);
  201.         string.Format(_T("   Active Connections - %s\n"),m_strSqlActiveConnections);
  202.         file.WriteString(string);
  203.         string.Format(_T("    Active Statements - %s\n"),m_strSqlActiveStatements);
  204.         file.WriteString(string);
  205.         string.Format(_T(" Multiple Result Sets - %s\n"),m_strSqlMultResultSets);
  206.         file.WriteString(string);
  207.         string.Format(_T("           File Usage - %s\n"),m_strSqlFileUsage);
  208.         file.WriteString(string);
  209.         string.Format(_T("    Read/Write Status - %s\n"),m_strSqlDataSourceReadOnly);
  210.         file.WriteString(string);
  211.         string.Format(_T("Accessible Procedures - %s\n"),m_strSqlAccessibleProcedures);
  212.         file.WriteString(string);
  213.         string.Format(_T("    Accessible Tables - %s\n\n"),m_strSqlAccessibleTables);
  214.         file.WriteString(string);
  215.     }
  216. }
  217.  
  218. void CDriverInfo::DoDataExchange(CDataExchange* pDX)
  219. {
  220.     CPropertyPage::DoDataExchange(pDX);
  221.     //{{AFX_DATA_MAP(CDriverInfo)
  222.     DDX_Text(pDX, IDC_SQL_USER_NAME, m_strSqlUserName);
  223.     DDX_Text(pDX, IDC_SQL_SERVER_NAME, m_strSqlServerName);
  224.     DDX_Text(pDX, IDC_SQL_DBMS_NAME, m_strSqlDbmsName);
  225.     DDX_Text(pDX, IDC_SQL_DBMS_VER, m_strSqlDbmsVer);
  226.     DDX_Text(pDX, IDC_SQL_DRIVER_NAME, m_strSqlDriverName);
  227.     DDX_Text(pDX, IDC_SQL_DRIVER_ODBC_VER, m_strSqlDriverOdbcVer);
  228.     DDX_Text(pDX, IDC_SQL_DRIVER_VER, m_strSqlDriverVer);
  229.     DDX_Text(pDX, IDC_SQL_ODBC_VER, m_strSqlOdbcVer);
  230.     DDX_Text(pDX, IDC_SQL_ODBC_API_CONFORMANCE, m_strSqlOdbcApiConformance);
  231.     DDX_Text(pDX, IDC_SQL_ODBC_SAG_CLI_CONFORMANCE, m_strSqlOdbcSagCliConformance);
  232.     DDX_Text(pDX, IDC_SQL_ODBC_SQL_CONFORMANCE, m_strSqlOdbcSqlConformance);
  233.     DDX_Text(pDX, IDC_SQL_ODBC_SQL_OPT_IEF, m_strSqlOdbcSqlOptIef);
  234.     DDX_Text(pDX, IDC_SQL_ACTIVE_CONNECTIONS, m_strSqlActiveConnections);
  235.     DDX_Text(pDX, IDC_SQL_ACTIVE_STATEMENTS, m_strSqlActiveStatements);
  236.     DDX_Text(pDX, IDC_SQL_MULT_RESULT_SETS, m_strSqlMultResultSets);
  237.     DDX_Text(pDX, IDC_SQL_FILE_USAGE, m_strSqlFileUsage);
  238.     DDX_Text(pDX, IDC_SQL_DATA_SOURCE_READ_ONLY, m_strSqlDataSourceReadOnly);
  239.     DDX_Text(pDX, IDC_DSN, m_strSqlDataSourceName);
  240.     DDX_Text(pDX, IDC_SQL_ACCESSIBLE_PROCEDURES, m_strSqlAccessibleProcedures);
  241.     DDX_Text(pDX, IDC_SQL_ACCESSIBLE_TABLES, m_strSqlAccessibleTables);
  242.     DDX_Text(pDX, IDC_SQL_DATABASE_NAME, m_strSqlDatabaseName);
  243.     //}}AFX_DATA_MAP
  244. }
  245.  
  246. BEGIN_MESSAGE_MAP(CDriverInfo, CPropertyPage)
  247.     //{{AFX_MSG_MAP(CDriverInfo)
  248.     //}}AFX_MSG_MAP
  249. END_MESSAGE_MAP()
  250.  
  251. /////////////////////////////////////////////////////////////////////////////
  252. // CDriverInfo message handlers
  253.  
  254. void CDriverInfo::OnNewDSN()
  255. {
  256.     if (m_pDatabase->IsOpen())
  257.     {
  258.         SWORD    value;
  259.         CString    string;
  260.  
  261.         m_strSqlDataSourceName = SQLGetInfoString(SQL_DATA_SOURCE_NAME);
  262.         m_strSqlUserName = SQLGetInfoString(SQL_USER_NAME);
  263.         m_strSqlServerName = SQLGetInfoString(SQL_SERVER_NAME);
  264.         m_strSqlDatabaseName = SQLGetInfoString(SQL_DATABASE_NAME);
  265.         m_strSqlDbmsName = SQLGetInfoString(SQL_DBMS_NAME);
  266.         m_strSqlDbmsVer = SQLGetInfoString(SQL_DBMS_VER);
  267.         m_strSqlDriverName = SQLGetInfoString(SQL_DRIVER_NAME);
  268.         m_strSqlDriverVer = SQLGetInfoString(SQL_DRIVER_VER);
  269.         m_strSqlDriverOdbcVer = SQLGetInfoString(SQL_DRIVER_ODBC_VER);
  270.         m_strSqlOdbcVer = SQLGetInfoString(SQL_ODBC_VER);
  271.         switch (SQLGetInfoShort(SQL_ODBC_API_CONFORMANCE))
  272.         {
  273.         case SQL_OAC_NONE:
  274.             m_strSqlOdbcApiConformance = _T("Core");
  275.             break;
  276.         case SQL_OAC_LEVEL1:
  277.             m_strSqlOdbcApiConformance = _T("Level 1");
  278.             break;
  279.         case SQL_OAC_LEVEL2:
  280.             m_strSqlOdbcApiConformance = _T("Level 2");
  281.             break;
  282.         }
  283.         switch (SQLGetInfoShort(SQL_ODBC_SQL_CONFORMANCE))
  284.         {
  285.         case SQL_OSC_MINIMUM:
  286.             m_strSqlOdbcSqlConformance = _T("Minimum");
  287.             break;
  288.         case SQL_OSC_CORE:
  289.             m_strSqlOdbcSqlConformance = _T("Core");
  290.             break;
  291.         case SQL_OSC_EXTENDED:
  292.             m_strSqlOdbcSqlConformance = _T("Extended");
  293.             break;
  294.         }
  295.         switch (SQLGetInfoShort(SQL_ODBC_SAG_CLI_CONFORMANCE))
  296.         {
  297.         case SQL_OSCC_NOT_COMPLIANT:
  298.             m_strSqlOdbcSagCliConformance = _T("No");
  299.             break;
  300.         case SQL_OSCC_COMPLIANT:
  301.             m_strSqlOdbcSagCliConformance = _T("Yes");
  302.             break;
  303.         }
  304.         YIsSupported(m_strSqlOdbcSqlOptIef,SQL_ODBC_SQL_OPT_IEF);
  305.         if (value = SQLGetInfoShort(SQL_ACTIVE_CONNECTIONS))
  306.             m_strSqlActiveConnections.Format(_T("%d"),value);
  307.         else
  308.             m_strSqlActiveConnections = _T("No Limit");
  309.         if (value = SQLGetInfoShort(SQL_ACTIVE_STATEMENTS))
  310.             m_strSqlActiveStatements.Format(_T("%d"),value);
  311.         else
  312.             m_strSqlActiveStatements = _T("No Limit");
  313.         YIsSupported(m_strSqlMultResultSets,SQL_MULT_RESULT_SETS);
  314.         switch (SQLGetInfoShort(SQL_FILE_USAGE))
  315.         {
  316.         case SQL_FILE_NOT_SUPPORTED:
  317.             m_strSqlFileUsage = _T("<n/a>, Driver not single-tier");
  318.             break;
  319.         case SQL_FILE_TABLE:
  320.             m_strSqlFileUsage = _T("Files are Tables");
  321.             break;
  322.         case SQL_FILE_QUALIFIER:
  323.             m_strSqlFileUsage = _T("Files are Qualifiers");
  324.             break;
  325.         }
  326.         
  327.         string = SQLGetInfoString(SQL_DATA_SOURCE_READ_ONLY);
  328.         if (string == _T("Y"))
  329.             m_strSqlDataSourceReadOnly = _T("Data source is read-only");
  330.         else if (string == _T("N"))
  331.             m_strSqlDataSourceReadOnly = _T("Data source is read-write");
  332.  
  333.         YIsYes(m_strSqlAccessibleProcedures,SQL_ACCESSIBLE_PROCEDURES);
  334.         YIsYes(m_strSqlAccessibleTables,SQL_ACCESSIBLE_TABLES);
  335.  
  336.         if (IsWindow(m_hWnd))
  337.             UpdateData(FALSE);
  338.     }
  339. }
  340.  
  341. BOOL CDriverInfo::OnInitDialog() 
  342. {
  343.     CPropertyPage::OnInitDialog();
  344.     
  345.     UpdateData(FALSE);
  346.     
  347.     return TRUE;  // return TRUE unless you set the focus to a control
  348.                   // EXCEPTION: OCX Property Pages should return FALSE
  349. }
  350.  
  351. /////////////////////////////////////////////////////////////////////////////
  352. // CFunctions property page
  353.  
  354. IMPLEMENT_DYNCREATE(CFunctions, CPropertyPage)
  355.  
  356. #define    CONVERSIONS_START            0
  357. #define    NUM_CONVERSIONS                1
  358.  
  359. #define    NUMERIC_START                1
  360. #define    NUM_NUMERICS                24
  361.  
  362. #define    STRINGS_START                25
  363. #define NUM_STRINGS                    19
  364.  
  365. #define    SYSTEMS_START                44
  366. #define    NUM_SYSTEMS                    3
  367.  
  368. #define    TIMEDATES_START                47
  369. #define    NUM_TIMEDATES                17
  370.  
  371. SDWORD    CFunctions::m_dwConversionsMasks[] =
  372. {
  373.     SQL_FN_CVT_CONVERT
  374. };
  375.  
  376. SDWORD    CFunctions::m_dwNumericMasks[] =
  377. {
  378.     SQL_FN_NUM_ABS,
  379.     SQL_FN_NUM_ACOS,
  380.     SQL_FN_NUM_ASIN,
  381.     SQL_FN_NUM_ATAN,
  382.     SQL_FN_NUM_ATAN2,
  383.     SQL_FN_NUM_CEILING,
  384.     SQL_FN_NUM_COS,
  385.     SQL_FN_NUM_COT,
  386.     SQL_FN_NUM_DEGREES,
  387.     SQL_FN_NUM_EXP,
  388.     SQL_FN_NUM_FLOOR,
  389.     SQL_FN_NUM_LOG,
  390.     SQL_FN_NUM_LOG10,
  391.     SQL_FN_NUM_MOD,
  392.     SQL_FN_NUM_PI,
  393.     SQL_FN_NUM_POWER,
  394.     SQL_FN_NUM_RADIANS,
  395.     SQL_FN_NUM_RAND,
  396.     SQL_FN_NUM_ROUND,
  397.     SQL_FN_NUM_SIGN,
  398.     SQL_FN_NUM_SIN,
  399.     SQL_FN_NUM_SQRT,
  400.     SQL_FN_NUM_TAN,
  401.     SQL_FN_NUM_TRUNCATE
  402. };
  403.  
  404. SDWORD    CFunctions::m_dwStringsMasks[] =
  405. {
  406.     SQL_FN_STR_ASCII,
  407.     SQL_FN_STR_CHAR,
  408.     SQL_FN_STR_CONCAT,
  409.     SQL_FN_STR_DIFFERENCE,
  410.     SQL_FN_STR_INSERT,
  411.     SQL_FN_STR_LCASE,
  412.     SQL_FN_STR_LEFT,
  413.     SQL_FN_STR_LENGTH,
  414.     SQL_FN_STR_LOCATE,
  415.     SQL_FN_STR_LOCATE_2,
  416.     SQL_FN_STR_LTRIM,
  417.     SQL_FN_STR_REPEAT,
  418.     SQL_FN_STR_REPLACE,
  419.     SQL_FN_STR_RIGHT,
  420.     SQL_FN_STR_RTRIM,
  421.     SQL_FN_STR_SOUNDEX,
  422.     SQL_FN_STR_SPACE,
  423.     SQL_FN_STR_SUBSTRING,
  424.     SQL_FN_STR_UCASE
  425. };
  426.  
  427. SDWORD    CFunctions::m_dwSystemsMasks[] =
  428. {
  429.     SQL_FN_SYS_DBNAME,
  430.     SQL_FN_SYS_IFNULL,
  431.     SQL_FN_SYS_USERNAME,
  432. };
  433.  
  434. SDWORD    CFunctions::m_dwTimeDatesMasks[] =
  435. {
  436.     SQL_FN_TD_CURDATE,
  437.     SQL_FN_TD_CURTIME,
  438.     SQL_FN_TD_DAYNAME,
  439.     SQL_FN_TD_DAYOFMONTH,
  440.     SQL_FN_TD_DAYOFWEEK,
  441.     SQL_FN_TD_DAYOFYEAR,
  442.     SQL_FN_TD_HOUR,
  443.     SQL_FN_TD_MINUTE,
  444.     SQL_FN_TD_MONTH,
  445.     SQL_FN_TD_MONTHNAME,
  446.     SQL_FN_TD_NOW,
  447.     SQL_FN_TD_QUARTER,
  448.     SQL_FN_TD_SECOND,
  449.     SQL_FN_TD_TIMESTAMPADD,
  450.     SQL_FN_TD_TIMESTAMPDIFF,
  451.     SQL_FN_TD_WEEK,
  452.     SQL_FN_TD_YEAR,
  453. };
  454.  
  455. char*    CFunctions::m_szSqlFunctions[] =
  456. {
  457.     _T("Convert()"),    // conversion
  458.     _T("Abs()"),        // numeric
  459.     _T("Acos()"),
  460.     _T("Asin()"),
  461.     _T("Atan()"),
  462.     _T("Atan2()"),
  463.     _T("Ceiling()"),
  464.     _T("Cos()"),
  465.     _T("Cot()"),
  466.     _T("Degrees()"),
  467.     _T("Exp()"),
  468.     _T("Floor()"),
  469.     _T("Log()"),
  470.     _T("Log10()"),
  471.     _T("Mod()"),
  472.     _T("Pi()"),
  473.     _T("Power()"),
  474.     _T("Radians()"),
  475.     _T("Rand()"),
  476.     _T("Round()"),
  477.     _T("Sign()"),
  478.     _T("Sin()"),
  479.     _T("Sqrt()"),
  480.     _T("Tan()"),
  481.     _T("Truncate()"),
  482.     _T("Ascii()"),
  483.     _T("Char()"),
  484.     _T("Concat()"),
  485.     _T("Difference()"),
  486.     _T("Insert()"),
  487.     _T("LCase()"),
  488.     _T("Left()"),
  489.     _T("Lenght()"),
  490.     _T("Locate()"),
  491.     _T("Locate2()"),
  492.     _T("LTrim()"),
  493.     _T("Repeat()"),
  494.     _T("Replace()"),
  495.     _T("Right()"),
  496.     _T("RTrim()"),
  497.     _T("Soundex()"),
  498.     _T("Space()"),
  499.     _T("Substring()"),
  500.     _T("UCase()"),
  501.     _T("DBName()"),
  502.     _T("IfNull()"),
  503.     _T("UserName()"),
  504.     _T("CurDate()"),
  505.     _T("CurTime()"),
  506.     _T("DayName()"),
  507.     _T("DayOfMonth()"),
  508.     _T("DayOfWeek()"),
  509.     _T("DayOfYear()"),
  510.     _T("Hour()"),
  511.     _T("Minute()"),
  512.     _T("Month()"),
  513.     _T("MonthName()"),
  514.     _T("Now()"),
  515.     _T("Quarter()"),
  516.     _T("Second()"),
  517.     _T("TimeStampAdd()"),
  518.     _T("TimeStampDiff()"),
  519.     _T("Week()"),
  520.     _T("Year()")
  521. };
  522.  
  523. char* CFunctions::m_szSqlCategories[] =
  524. {
  525.     _T("Conversion"),
  526.     _T("Numeric"),
  527.     _T("Numeric"),
  528.     _T("Numeric"),
  529.     _T("Numeric"),
  530.     _T("Numeric"),
  531.     _T("Numeric"),
  532.     _T("Numeric"),
  533.     _T("Numeric"),
  534.     _T("Numeric"),
  535.     _T("Numeric"),
  536.     _T("Numeric"),
  537.     _T("Numeric"),
  538.     _T("Numeric"),
  539.     _T("Numeric"),
  540.     _T("Numeric"),
  541.     _T("Numeric"),
  542.     _T("Numeric"),
  543.     _T("Numeric"),
  544.     _T("Numeric"),
  545.     _T("Numeric"),
  546.     _T("Numeric"),
  547.     _T("Numeric"),
  548.     _T("Numeric"),
  549.     _T("Numeric"),
  550.     _T("String"),
  551.     _T("String"),
  552.     _T("String"),
  553.     _T("String"),
  554.     _T("String"),
  555.     _T("String"),
  556.     _T("String"),
  557.     _T("String"),
  558.     _T("String"),
  559.     _T("String"),
  560.     _T("String"),
  561.     _T("String"),
  562.     _T("String"),
  563.     _T("String"),
  564.     _T("String"),
  565.     _T("String"),
  566.     _T("String"),
  567.     _T("String"),
  568.     _T("String"),
  569.     _T("System"),
  570.     _T("System"),
  571.     _T("System"),
  572.     _T("TimeDate"),
  573.     _T("TimeDate"),
  574.     _T("TimeDate"),
  575.     _T("TimeDate"),
  576.     _T("TimeDate"),
  577.     _T("TimeDate"),
  578.     _T("TimeDate"),
  579.     _T("TimeDate"),
  580.     _T("TimeDate"),
  581.     _T("TimeDate"),
  582.     _T("TimeDate"),
  583.     _T("TimeDate"),
  584.     _T("TimeDate"),
  585.     _T("TimeDate"),
  586.     _T("TimeDate"),
  587.     _T("TimeDate"),
  588.     _T("TimeDate")
  589. };
  590.  
  591. char* CFunctions::m_szFunctions[] =
  592. {
  593.     _T("SQLAllocConnect"),
  594.     _T("SQLAllocEnv"),
  595.     _T("SQLAllocStmt"),
  596.     _T("SQLBindCol"),
  597.     _T("SQLCancel"),
  598.     _T("SQLColAttributes"),
  599.     _T("SQLConnect"),
  600.     _T("SQLDescribeCol"),
  601.     _T("SQLDisconnect"),
  602.     _T("SQLError"),
  603.     _T("SQLExecDirect"),
  604.     _T("SQLExecute"),
  605.     _T("SQLFetch"),
  606.     _T("SQLFreeConnect"),
  607.     _T("SQLFreeEnv"),
  608.     _T("SQLFreeStmt"),
  609.     _T("SQLGetCursorName"),
  610.     _T("SQLNumResultCols"),
  611.     _T("SQLPrepare"),
  612.     _T("SQLRowCount"),
  613.     _T("SQLSetCursorName"),
  614.     _T("SQLSetParam"),
  615.     _T("SQLTransact"),
  616.     _T(""),
  617.     _T(""),
  618.     _T(""),
  619.     _T(""),
  620.     _T(""),
  621.     _T(""),
  622.     _T(""),
  623.     _T(""),
  624.     _T(""),
  625.     _T(""),
  626.     _T(""),
  627.     _T(""),
  628.     _T(""),
  629.     _T(""),
  630.     _T(""),
  631.     _T(""),
  632.     _T("SQLColumns"),
  633.     _T("SQLDriverConnect"),
  634.     _T("SQLGetConnectOption"),
  635.     _T("SQLGetData"),
  636.     _T("SQLGetFunctions"),
  637.     _T("SQLGetInfo"),
  638.     _T("SQLGetStmtOption"),
  639.     _T("SQLGetTypeInfo"),
  640.     _T("SQLParamData"),
  641.     _T("SQLPutData"),
  642.     _T("SQLSetConnectOption"),
  643.     _T("SQLSetStmtOption"),
  644.     _T("SQLSpecialColumns"),
  645.     _T("SQLStatistics"),
  646.     _T("SQLTables"),
  647.     _T("SQLBrowseConnect"),
  648.     _T("SQLColumnPrivileges"),
  649.     _T("SQLDataSources"),
  650.     _T("SQLDescribeParam"),
  651.     _T("SQLExtendedFetch"),
  652.     _T("SQLForeignKeys"),
  653.     _T("SQLMoreResults"),
  654.     _T("SQLNativeSql"),
  655.     _T("SQLNumParams"),
  656.     _T("SQLParamOptions"),
  657.     _T("SQLPrimaryKeys"),
  658.     _T("SQLProcedureColumns"),
  659.     _T("SQLProcedures"),
  660.     _T("SQLSetPos"),
  661.     _T("SQLSetScrollOptions"),
  662.     _T("SQLTablePrivileges"),
  663.     _T("SQLDrivers"),
  664.     _T("SQLBindParameter")
  665.     _T(""),
  666.     _T(""),
  667.     _T(""),
  668.     _T(""),
  669.     _T(""),
  670.     _T(""),
  671.     _T(""),
  672.     _T(""),
  673.     _T(""),
  674.     _T(""),
  675.     _T(""),
  676.     _T(""),
  677.     _T(""),
  678.     _T(""),
  679.     _T(""),
  680.     _T(""),
  681.     _T(""),
  682.     _T(""),
  683.     _T(""),
  684.     _T(""),
  685.     _T(""),
  686.     _T(""),
  687.     _T(""),
  688.     _T(""),
  689.     _T(""),
  690.     _T(""),
  691.     _T(""),
  692.     _T(""),
  693. };
  694.  
  695. CFunctions::CFunctions(CDatabase* pDatabase)
  696.  : CMyPage(pDatabase, CFunctions::IDD)
  697. {
  698.     //{{AFX_DATA_INIT(CFunctions)
  699.     //}}AFX_DATA_INIT
  700. }
  701.  
  702. CFunctions::~CFunctions()
  703. {
  704. }
  705.  
  706. void CFunctions::DumpToFile(CStdioFile& file)
  707. {
  708.     if (m_pDatabase->IsOpen())
  709.     {
  710.         int        i,j;
  711.         CString    string;
  712.         CString    padString;
  713.         UWORD    aFunctions[100];
  714.         SDWORD    value;
  715.  
  716.         file.WriteString(_T("ODBC API Functions\n------------------\n"));
  717.         ::SQLGetFunctions(m_pDatabase->m_hdbc,
  718.                 SQL_API_ALL_FUNCTIONS,aFunctions);
  719.         for (i = 0; i < SQL_NUM_FUNCTIONS; i++)
  720.         {
  721.             if (aFunctions[i + 1])
  722.                 string.Format(_T("%s - Supported\n"),m_szFunctions[i]);
  723.             else
  724.                 string.Format(_T("%s - Not Supported\n"),m_szFunctions[i]);
  725.             padString = _T("");
  726.             int nLimit = 21 - lstrlen(m_szFunctions[i]) / sizeof(TCHAR);
  727.             if (nLimit > 0)
  728.             {
  729.                 for (j = 0; j < nLimit; j++)
  730.                     padString += ' ';
  731.                 file.WriteString(padString);
  732.             }
  733.             file.WriteString(string);
  734.         }
  735.         for (i = 0; i < SQL_EXT_API_LAST - SQL_EXT_API_START + 1; i++)
  736.         {
  737.             if (aFunctions[i + SQL_EXT_API_START])
  738.                 string.Format(_T("%s - Supported\n"),m_szFunctions[i + SQL_EXT_API_START - 1]);
  739.             else
  740.                 string.Format(_T("%s - Not Supported\n"),m_szFunctions[i + SQL_EXT_API_START - 1]);
  741.             padString = _T("");
  742.             int nLimit = 21 - lstrlen(m_szFunctions[i + SQL_EXT_API_START - 1]) / sizeof(TCHAR);
  743.             if (nLimit > 0)
  744.             {
  745.                 for (j = 0; j < nLimit; j++)
  746.                     padString += ' ';
  747.                 file.WriteString(padString);
  748.             }
  749.             file.WriteString(string);
  750.         }
  751.         file.WriteString(_T("\n"));
  752.  
  753.         file.WriteString(_T("SQL Conversion Functions\n------------------------\n"));
  754.         value = SQLGetInfoLong(SQL_CONVERT_FUNCTIONS);
  755.         for (i = 0; i < NUM_CONVERSIONS; i++)
  756.         {
  757.             if (value & m_dwConversionsMasks[i])
  758.                 string.Format(_T("%s - Supported\n"),m_szSqlFunctions[CONVERSIONS_START + i]);
  759.             else
  760.                 string.Format(_T("%s - Not Supported\n"),m_szSqlFunctions[CONVERSIONS_START + i]);
  761.             padString = _T("");
  762.             int nLimit = 21 - lstrlen(m_szSqlFunctions[CONVERSIONS_START + i]) / sizeof(TCHAR);
  763.             if (nLimit > 0)
  764.             {
  765.                 for (j = 0; j < nLimit; j++)
  766.                     padString += ' ';
  767.                 file.WriteString(padString);
  768.             }
  769.             file.WriteString(string);
  770.         }
  771.         file.WriteString(_T("\n"));
  772.  
  773.         file.WriteString(_T("SQL Numeric Functions\n---------------------\n"));
  774.         value = SQLGetInfoLong(SQL_NUMERIC_FUNCTIONS);
  775.         for (i = 0; i < NUM_NUMERICS; i++)
  776.         {
  777.             if (value & m_dwNumericMasks[i])
  778.                 string.Format(_T("%s - Supported\n"),m_szSqlFunctions[NUMERIC_START + i]);
  779.             else
  780.                 string.Format(_T("%s - Not Supported\n"),m_szSqlFunctions[NUMERIC_START + i]);
  781.             padString = _T("");
  782.             int nLimit = 21 - lstrlen(m_szSqlFunctions[NUMERIC_START + i]) / sizeof(TCHAR);
  783.             if (nLimit > 0)
  784.             {
  785.                 for (j = 0; j < nLimit; j++)
  786.                     padString += ' ';
  787.                 file.WriteString(padString);
  788.             }
  789.             file.WriteString(string);
  790.         }
  791.         file.WriteString(_T("\n"));
  792.  
  793.         file.WriteString(_T("SQL String Functions\n--------------------\n"));
  794.         value = SQLGetInfoLong(SQL_STRING_FUNCTIONS);
  795.         for (i = 0; i < NUM_STRINGS; i++)
  796.         {
  797.             if (value & m_dwStringsMasks[i])
  798.                 string.Format(_T("%s - Supported\n"),m_szSqlFunctions[STRINGS_START + i]);
  799.             else
  800.                 string.Format(_T("%s - Not Supported\n"),m_szSqlFunctions[STRINGS_START + i]);
  801.             padString = _T("");
  802.             int nLimit = 21 - lstrlen(m_szSqlFunctions[STRINGS_START + i]) / sizeof(TCHAR);
  803.             if (nLimit > 0)
  804.             {
  805.                 for (j = 0; j < nLimit; j++)
  806.                     padString += ' ';
  807.                 file.WriteString(padString);
  808.             }
  809.             file.WriteString(string);
  810.         }
  811.         file.WriteString(_T("\n"));
  812.  
  813.         file.WriteString(_T("SQL System Functions\n--------------------\n"));
  814.         value = SQLGetInfoLong(SQL_SYSTEM_FUNCTIONS);
  815.         for (i = 0; i < NUM_SYSTEMS; i++)
  816.         {
  817.             if (value & m_dwSystemsMasks[i])
  818.                 string.Format(_T("%s - Supported\n"),m_szSqlFunctions[SYSTEMS_START + i]);
  819.             else
  820.                 string.Format(_T("%s - Not Supported\n"),m_szSqlFunctions[SYSTEMS_START + i]);
  821.             padString = _T("");
  822.             int nLimit = 21 - lstrlen(m_szSqlFunctions[SYSTEMS_START + i]) / sizeof(TCHAR);
  823.             if (nLimit > 0)
  824.             {
  825.                 for (j = 0; j < nLimit; j++)
  826.                     padString += ' ';
  827.                 file.WriteString(padString);
  828.             }
  829.             file.WriteString(string);
  830.         }
  831.         file.WriteString(_T("\n"));
  832.  
  833.         file.WriteString(_T("SQL Time/Date Functions\n-----------------------\n"));
  834.         value = SQLGetInfoLong(SQL_TIMEDATE_FUNCTIONS);
  835.         for (i = 0; i < NUM_TIMEDATES; i++)
  836.         {
  837.             if (value & m_dwTimeDatesMasks[i])
  838.                 string.Format(_T("%s - Supported\n"),m_szSqlFunctions[TIMEDATES_START + i]);
  839.             else
  840.                 string.Format(_T("%s - Not Supported\n"),m_szSqlFunctions[TIMEDATES_START + i]);
  841.             padString = _T("");
  842.             int nLimit = 21 - lstrlen(m_szSqlFunctions[TIMEDATES_START + i]) / sizeof(TCHAR);
  843.             if (nLimit > 0)
  844.             {
  845.                 for (j = 0; j < nLimit; j++)
  846.                     padString += ' ';
  847.                 file.WriteString(padString);
  848.             }
  849.             file.WriteString(string);
  850.         }
  851.         file.WriteString(_T("\n"));
  852.     }
  853. }
  854.  
  855. void CFunctions::DoDataExchange(CDataExchange* pDX)
  856. {
  857.     CPropertyPage::DoDataExchange(pDX);
  858.     //{{AFX_DATA_MAP(CFunctions)
  859.     DDX_Control(pDX, IDC_SQL_FUNCTIONS, m_SqlListControl);
  860.     DDX_Control(pDX, IDC_API_FUNCTIONS, m_ApiListControl);
  861.     //}}AFX_DATA_MAP
  862. }
  863.  
  864.  
  865. BEGIN_MESSAGE_MAP(CFunctions, CPropertyPage)
  866.     //{{AFX_MSG_MAP(CFunctions)
  867.     //}}AFX_MSG_MAP
  868. END_MESSAGE_MAP()
  869.  
  870. /////////////////////////////////////////////////////////////////////////////
  871. // CFunctions message handlers
  872. void CFunctions::OnNewDSN()
  873. {
  874.     if (::IsWindow(m_hWnd))
  875.     {
  876.         UWORD        aFunctions[100];
  877.         BOOL        bOpen = m_pDatabase->IsOpen();
  878.  
  879.         SDWORD        value;
  880.         int            nNewItem;
  881.  
  882.         m_ApiListControl.DeleteAllItems();
  883.         if (bOpen)
  884.             ::SQLGetFunctions(m_pDatabase->m_hdbc,
  885.                 SQL_API_ALL_FUNCTIONS,aFunctions);
  886.         for (int i = 0; i < SQL_NUM_FUNCTIONS; i++)
  887.         {
  888.             if (bOpen && aFunctions[i + 1])
  889.                 m_ApiListControl.InsertItem(i,m_szFunctions[i],1);
  890.             else
  891.                 m_ApiListControl.InsertItem(i,m_szFunctions[i],0);
  892.         }
  893.     
  894.         for (i = 0; i < SQL_EXT_API_LAST - SQL_EXT_API_START + 1; i++)
  895.         {
  896.             if (bOpen && aFunctions[i+SQL_EXT_API_START])
  897.                 m_ApiListControl.InsertItem(i+SQL_NUM_FUNCTIONS,
  898.                     m_szFunctions[i+SQL_EXT_API_START-1],1);
  899.             else
  900.                 m_ApiListControl.InsertItem(i+SQL_NUM_FUNCTIONS,
  901.                     m_szFunctions[i+SQL_EXT_API_START-1],0);
  902.         }
  903.  
  904.         m_SqlListControl.DeleteAllItems();
  905.  
  906.         // conversion function
  907.         if (bOpen)
  908.             value = SQLGetInfoLong(SQL_CONVERT_FUNCTIONS);
  909.         for (i = 0; i < NUM_CONVERSIONS; i++)
  910.         {
  911.             if (bOpen && (value & m_dwConversionsMasks[i]))
  912.                 nNewItem = m_SqlListControl.InsertItem(CONVERSIONS_START + i,
  913.                     m_szSqlFunctions[CONVERSIONS_START + i],1);
  914.             else
  915.                 nNewItem = m_SqlListControl.InsertItem(CONVERSIONS_START + i,
  916.                     m_szSqlFunctions[CONVERSIONS_START + i],0);
  917.             m_SqlListControl.SetItem(nNewItem,1,LVIF_TEXT,
  918.                 m_szSqlCategories[CONVERSIONS_START + i],0,0,0,0);
  919.         }
  920.  
  921.         // numeric functions
  922.         if (bOpen)
  923.             value = SQLGetInfoLong(SQL_NUMERIC_FUNCTIONS);
  924.         for (i = 0; i < NUM_NUMERICS; i++)
  925.         {
  926.             if (bOpen && (value & m_dwNumericMasks[i]))
  927.                 nNewItem = m_SqlListControl.InsertItem(NUMERIC_START + i,
  928.                     m_szSqlFunctions[NUMERIC_START + i],1);
  929.             else
  930.                 nNewItem = m_SqlListControl.InsertItem(NUMERIC_START + i,
  931.                     m_szSqlFunctions[NUMERIC_START + i],0);
  932.             m_SqlListControl.SetItem(nNewItem,1,LVIF_TEXT,
  933.                 m_szSqlCategories[NUMERIC_START + i],0,0,0,0);
  934.         }
  935.  
  936.         // string functions
  937.         if (bOpen)
  938.             value = SQLGetInfoLong(SQL_STRING_FUNCTIONS);
  939.         for (i = 0; i < NUM_STRINGS; i++)
  940.         {
  941.             if (bOpen && (value & m_dwStringsMasks[i]))
  942.                 nNewItem = m_SqlListControl.InsertItem(STRINGS_START + i,
  943.                     m_szSqlFunctions[STRINGS_START + i],1);
  944.             else
  945.                 nNewItem = m_SqlListControl.InsertItem(STRINGS_START + i,
  946.                     m_szSqlFunctions[STRINGS_START + i],0);
  947.             m_SqlListControl.SetItem(nNewItem,1,LVIF_TEXT,
  948.                 m_szSqlCategories[STRINGS_START + i],0,0,0,0);
  949.         }
  950.  
  951.         // system functions
  952.         if (bOpen)
  953.             value = SQLGetInfoLong(SQL_SYSTEM_FUNCTIONS);
  954.         for (i = 0; i < NUM_SYSTEMS; i++)
  955.         {
  956.             if (bOpen && (value & m_dwSystemsMasks[i]))
  957.                 nNewItem = m_SqlListControl.InsertItem(SYSTEMS_START + i,
  958.                     m_szSqlFunctions[SYSTEMS_START + i],1);
  959.             else
  960.                 nNewItem = m_SqlListControl.InsertItem(SYSTEMS_START + i,
  961.                     m_szSqlFunctions[SYSTEMS_START + i],0);
  962.             m_SqlListControl.SetItem(nNewItem,1,LVIF_TEXT,
  963.                 m_szSqlCategories[SYSTEMS_START + i],0,0,0,0);
  964.         }
  965.  
  966.         // timedate functions
  967.         if (bOpen)
  968.             value = SQLGetInfoLong(SQL_TIMEDATE_FUNCTIONS);
  969.         for (i = 0; i < NUM_TIMEDATES; i++)
  970.         {
  971.             if (bOpen && (value & m_dwTimeDatesMasks[i]))
  972.                 nNewItem = m_SqlListControl.InsertItem(TIMEDATES_START + i,
  973.                     m_szSqlFunctions[TIMEDATES_START + i],1);
  974.             else
  975.                 nNewItem = m_SqlListControl.InsertItem(TIMEDATES_START + i,
  976.                     m_szSqlFunctions[TIMEDATES_START + i],0);
  977.             m_SqlListControl.SetItem(nNewItem,1,LVIF_TEXT,
  978.                 m_szSqlCategories[TIMEDATES_START + i],0,0,0,0);
  979.         }
  980.     }
  981. }
  982.  
  983. BOOL CFunctions::OnInitDialog() 
  984. {
  985.     CPropertyPage::OnInitDialog();
  986.  
  987.     m_ApiListControl.SetImageList(m_pImageList,LVSIL_SMALL);
  988.     m_SqlListControl.SetImageList(m_pImageList,LVSIL_SMALL);
  989.  
  990.     m_ApiListControl.InsertColumn(0,"",LVCFMT_LEFT,130);
  991.     m_SqlListControl.InsertColumn(0,"Function",LVCFMT_LEFT,120);
  992.     m_SqlListControl.InsertColumn(1,"Category",LVCFMT_LEFT,120);
  993.  
  994.     OnNewDSN();
  995.     
  996.     return TRUE;  // return TRUE unless you set the focus to a control
  997.                   // EXCEPTION: OCX Property Pages should return FALSE
  998. }
  999.  
  1000. /////////////////////////////////////////////////////////////////////////////
  1001. // CSupportedSQL property page
  1002.  
  1003. IMPLEMENT_DYNCREATE(CSupportedSQL, CPropertyPage)
  1004.  
  1005. CSupportedSQL::CSupportedSQL(CDatabase* pDatabase)
  1006.  : CMyPage(pDatabase,CSupportedSQL::IDD)
  1007. {
  1008.     //{{AFX_DATA_INIT(CSupportedSQL)
  1009.     m_bSqlAlterTableAdd = FALSE;
  1010.     m_bSqlAlterTableDrop = FALSE;
  1011.     m_strSqlExpressionsInOrderby = _T("");
  1012.     m_strSqlGroupBy = _T("");
  1013.     m_strSqlOrderByColumnsInSelect = _T("");
  1014.     m_strSqlOuterJoins = _T("");
  1015.     m_bSqlSqComparison = FALSE;
  1016.     m_bSqlSqCorrelatedSubqueries = FALSE;
  1017.     m_bSqlSqExists = FALSE;
  1018.     m_bSqlSqIn = FALSE;
  1019.     m_bSqlSqQuantified = FALSE;
  1020.     m_bSqlUUnion = FALSE;
  1021.     m_bSqlUUnionAll = FALSE;
  1022.     m_strSqlColumnAlias = _T("");
  1023.     m_strSqlLikeEscapeClause = _T("");
  1024.     m_bSqlPsPositionedDelete = FALSE;
  1025.     m_bSqlPsPositionedUpdate = FALSE;
  1026.     m_bSqlPsSelectForUpdate = FALSE;
  1027.     m_strSqlCorrelationName = _T("");
  1028.     //}}AFX_DATA_INIT
  1029.  
  1030.     OnNewDSN();
  1031. }
  1032.  
  1033. CSupportedSQL::~CSupportedSQL()
  1034. {
  1035. }
  1036.  
  1037. void CSupportedSQL::DumpToFile(CStdioFile& file)
  1038. {
  1039.     if (m_pDatabase->IsOpen())
  1040.     {
  1041.         BOOL    b;
  1042.         CString    string;
  1043.  
  1044.         file.WriteString(_T("Supported SQL\n-------------\n"));
  1045.         b = FALSE;
  1046.         file.WriteString(_T("  ALTER TABLE Support -"));
  1047.         if (m_bSqlAlterTableAdd)
  1048.         {
  1049.             file.WriteString(_T("ADD"));
  1050.             b = TRUE;
  1051.         }
  1052.         if (m_bSqlAlterTableDrop)
  1053.         {
  1054.             if (b)
  1055.                 file.WriteString(_T(","));
  1056.             file.WriteString(_T("DROP"));
  1057.             b = TRUE;
  1058.         }
  1059.         if (!b)
  1060.             file.WriteString(_T(" <none>"));
  1061.         file.WriteString(_T("\n"));
  1062.         string.Format(_T("       Column Aliases - %s\n"),m_strSqlColumnAlias);
  1063.         file.WriteString(string);
  1064.         string.Format(_T("    Correlation Names - %s\n"),m_strSqlCorrelationName);
  1065.         file.WriteString(string);
  1066.         string.Format(_T(" ORDER BY Expressions - %s\n"),m_strSqlExpressionsInOrderby);
  1067.         file.WriteString(string);
  1068.         string.Format(_T("GROUP BY NonAggregate - %s\n"),m_strSqlGroupBy);
  1069.         file.WriteString(string);
  1070.         string.Format(_T("LIKE Escape Character - %s\n"),m_strSqlLikeEscapeClause);
  1071.         file.WriteString(string);
  1072.         string.Format(_T("   ORDER BY in SELECT - %s\n"),m_strSqlOrderByColumnsInSelect);
  1073.         file.WriteString(string);
  1074.         string.Format(_T("   Outer Join Support - %s\n"),m_strSqlOuterJoins);
  1075.         file.WriteString(string);
  1076.  
  1077.         file.WriteString(_T("Positioned Statements -"));
  1078.         b = FALSE;
  1079.         if (m_bSqlPsPositionedDelete)
  1080.         {
  1081.             file.WriteString(_T("Delete"));
  1082.             b = TRUE;
  1083.         }
  1084.         if (m_bSqlPsPositionedUpdate)
  1085.         {
  1086.             if (b)
  1087.                 file.WriteString(_T(","));
  1088.             file.WriteString(_T("Update"));
  1089.             b = TRUE;
  1090.         }
  1091.         if (m_bSqlPsSelectForUpdate)
  1092.         {
  1093.             if (b)
  1094.                 file.WriteString(_T(","));
  1095.             file.WriteString(_T("Select for Update"));
  1096.             b = TRUE;
  1097.         }
  1098.         if (!b)
  1099.             file.WriteString(_T("<none>"));
  1100.         file.WriteString(_T("\n"));
  1101.  
  1102.         file.WriteString(_T("     Subquery Support -"));
  1103.         b = FALSE;
  1104.         if (m_bSqlSqCorrelatedSubqueries)
  1105.         {
  1106.             file.WriteString(_T("Correlated"));
  1107.             b = TRUE;
  1108.         }
  1109.         if (m_bSqlSqComparison)
  1110.         {
  1111.             if (b)
  1112.                 file.WriteString(_T(","));
  1113.             file.WriteString(_T("Comparison"));
  1114.             b = TRUE;
  1115.         }
  1116.         if (m_bSqlSqExists)
  1117.         {
  1118.             if (b)
  1119.                 file.WriteString(_T(","));
  1120.             file.WriteString(_T("EXISTS"));
  1121.             b = TRUE;
  1122.         }
  1123.         if (m_bSqlSqIn)
  1124.         {
  1125.             if (b)
  1126.                 file.WriteString(_T(","));
  1127.             file.WriteString(_T("IN"));
  1128.             b = TRUE;
  1129.         }
  1130.         if (m_bSqlSqQuantified)
  1131.         {
  1132.             if (b)
  1133.                 file.WriteString(_T(","));
  1134.             file.WriteString(_T("Quantified"));
  1135.             b = TRUE;
  1136.         }
  1137.         if (!b)
  1138.             file.WriteString(_T("<none>"));
  1139.         file.WriteString(_T("\n"));
  1140.  
  1141.         file.WriteString(_T("        UNION Support -"));
  1142.         b = FALSE;
  1143.         if (m_bSqlUUnion)
  1144.         {
  1145.             file.WriteString(_T("UNION"));
  1146.             b = TRUE;
  1147.         }
  1148.         if (m_bSqlUUnionAll)
  1149.         {
  1150.             if (b)
  1151.                 file.WriteString(_T(","));
  1152.             file.WriteString(_T("UNION with ALL"));
  1153.             b = TRUE;
  1154.         }
  1155.         if (!b)
  1156.             file.WriteString(_T("<none>"));
  1157.         file.WriteString(_T("\n\n"));
  1158.     }
  1159. }
  1160.  
  1161. void CSupportedSQL::DoDataExchange(CDataExchange* pDX)
  1162. {
  1163.     CPropertyPage::DoDataExchange(pDX);
  1164.     //{{AFX_DATA_MAP(CSupportedSQL)
  1165.     DDX_Check(pDX, IDC_AT_ADD, m_bSqlAlterTableAdd);
  1166.     DDX_Check(pDX, IDC_AT_DROP, m_bSqlAlterTableDrop);
  1167.     DDX_Text(pDX, IDC_SQL_EXPRESSIONS_IN_ORDERBY, m_strSqlExpressionsInOrderby);
  1168.     DDX_Text(pDX, IDC_SQL_GROUP_BY, m_strSqlGroupBy);
  1169.     DDX_Text(pDX, IDC_SQL_ORDER_BY_COLUMNS_IN_SELECT, m_strSqlOrderByColumnsInSelect);
  1170.     DDX_Text(pDX, IDC_SQL_OUTER_JOINS, m_strSqlOuterJoins);
  1171.     DDX_Check(pDX, IDC_SQL_SQ_COMPARISON, m_bSqlSqComparison);
  1172.     DDX_Check(pDX, IDC_SQL_SQ_CORRELATED_SUBQUERIES, m_bSqlSqCorrelatedSubqueries);
  1173.     DDX_Check(pDX, IDC_SQL_SQ_EXISTS, m_bSqlSqExists);
  1174.     DDX_Check(pDX, IDC_SQL_SQ_IN, m_bSqlSqIn);
  1175.     DDX_Check(pDX, IDC_SQL_SQ_QUANTIFIED, m_bSqlSqQuantified);
  1176.     DDX_Check(pDX, IDC_SQL_U_UNION, m_bSqlUUnion);
  1177.     DDX_Check(pDX, IDC_SQL_U_UNION_ALL, m_bSqlUUnionAll);
  1178.     DDX_Text(pDX, IDC_SQL_COLUMN_ALIAS, m_strSqlColumnAlias);
  1179.     DDX_Text(pDX, IDC_SQL_LIKE_ESCAPE_CLAUSE, m_strSqlLikeEscapeClause);
  1180.     DDX_Check(pDX, IDC_SQL_PS_POSITIONED_DELETE, m_bSqlPsPositionedDelete);
  1181.     DDX_Check(pDX, IDC_SQL_PS_POSITIONED_UPDATE, m_bSqlPsPositionedUpdate);
  1182.     DDX_Check(pDX, IDC_SQL_PS_SELECT_FOR_UPDATE, m_bSqlPsSelectForUpdate);
  1183.     DDX_Text(pDX, IDC_SQL_CORRELATION_NAME, m_strSqlCorrelationName);
  1184.     //}}AFX_DATA_MAP
  1185. }
  1186.  
  1187.  
  1188. BEGIN_MESSAGE_MAP(CSupportedSQL, CPropertyPage)
  1189.     //{{AFX_MSG_MAP(CSupportedSQL)
  1190.     //}}AFX_MSG_MAP
  1191. END_MESSAGE_MAP()
  1192.  
  1193. /////////////////////////////////////////////////////////////////////////////
  1194. // CSupportedSQL message handlers
  1195.  
  1196. void CSupportedSQL::OnNewDSN()
  1197. {
  1198.     if (m_pDatabase->IsOpen())
  1199.     {
  1200.         CString    string;
  1201.         SDWORD    longValue;
  1202.  
  1203.         longValue = SQLGetInfoLong(SQL_ALTER_TABLE);
  1204.         if (longValue & SQL_AT_ADD_COLUMN)
  1205.             m_bSqlAlterTableAdd = TRUE;
  1206.         else
  1207.             m_bSqlAlterTableAdd = FALSE;
  1208.         if (longValue & SQL_AT_DROP_COLUMN)
  1209.             m_bSqlAlterTableDrop = TRUE;
  1210.         else
  1211.             m_bSqlAlterTableDrop = FALSE;
  1212.         YIsSupported(m_strSqlColumnAlias,SQL_COLUMN_ALIAS);
  1213.         switch (SQLGetInfoShort(SQL_CORRELATION_NAME))
  1214.         {
  1215.         case SQL_CN_NONE:
  1216.             m_strSqlCorrelationName = _T("Not Supported");
  1217.             break;
  1218.         case SQL_CN_DIFFERENT:
  1219.             m_strSqlCorrelationName = _T("Supported, table names must be different");
  1220.             break;
  1221.         case SQL_CN_ANY:
  1222.             m_strSqlCorrelationName = _T("Supported");
  1223.             break;
  1224.         }
  1225.         YIsSupported(m_strSqlExpressionsInOrderby,SQL_EXPRESSIONS_IN_ORDERBY);
  1226.         switch (SQLGetInfoShort(SQL_GROUP_BY))
  1227.         {
  1228.         case SQL_GB_NOT_SUPPORTED:
  1229.             m_strSqlGroupBy = _T("GROUP BY Not Supported");
  1230.             break;
  1231.         case SQL_GB_GROUP_BY_EQUALS_SELECT:
  1232.             m_strSqlGroupBy = _T("GROUP BY Equals SELECT");
  1233.             break;
  1234.         case SQL_GB_GROUP_BY_CONTAINS_SELECT:
  1235.             m_strSqlGroupBy = _T("GROUP BY Contains SELECT");
  1236.             break;
  1237.         case SQL_GB_NO_RELATION:
  1238.             m_strSqlGroupBy = _T("No Relation");
  1239.             break;
  1240.         }
  1241.         YIsSupported(m_strSqlLikeEscapeClause,SQL_LIKE_ESCAPE_CLAUSE);
  1242.         YIsYes(m_strSqlOrderByColumnsInSelect,SQL_ORDER_BY_COLUMNS_IN_SELECT);
  1243.         string = SQLGetInfoString(SQL_OUTER_JOINS);
  1244.         if (string == _T("N"))
  1245.             m_strSqlOuterJoins = _T("No");
  1246.         else if (string == _T("Y"))
  1247.             m_strSqlOuterJoins = _T("Yes");
  1248.         else if (string == _T("P"))
  1249.             m_strSqlOuterJoins = _T("Partial");
  1250.         else if (string == _T("F"))
  1251.             m_strSqlOuterJoins = _T("Full");
  1252.         longValue = SQLGetInfoLong(SQL_POSITIONED_STATEMENTS);
  1253.         if (longValue & SQL_PS_POSITIONED_DELETE)
  1254.             m_bSqlPsPositionedDelete = TRUE;
  1255.         else
  1256.             m_bSqlPsPositionedDelete = FALSE;
  1257.         if (longValue & SQL_PS_POSITIONED_UPDATE)
  1258.             m_bSqlPsPositionedUpdate = TRUE;
  1259.         else
  1260.             m_bSqlPsPositionedUpdate = FALSE;
  1261.         if (longValue & SQL_PS_SELECT_FOR_UPDATE)
  1262.             m_bSqlPsSelectForUpdate = TRUE;
  1263.         else
  1264.             m_bSqlPsSelectForUpdate = FALSE;
  1265.         longValue = SQLGetInfoLong(SQL_SUBQUERIES);
  1266.         if (longValue & SQL_SQ_CORRELATED_SUBQUERIES)
  1267.             m_bSqlSqCorrelatedSubqueries = TRUE;
  1268.         else
  1269.             m_bSqlSqCorrelatedSubqueries = FALSE;
  1270.         if (longValue & SQL_SQ_COMPARISON)
  1271.             m_bSqlSqComparison = TRUE;
  1272.         else
  1273.             m_bSqlSqComparison = FALSE;
  1274.         if (longValue & SQL_SQ_EXISTS)
  1275.             m_bSqlSqExists = TRUE;
  1276.         else
  1277.             m_bSqlSqExists = FALSE;
  1278.         if (longValue & SQL_SQ_IN)
  1279.             m_bSqlSqIn = TRUE;
  1280.         else
  1281.             m_bSqlSqIn = FALSE;
  1282.         if (longValue & SQL_SQ_QUANTIFIED)
  1283.             m_bSqlSqQuantified = TRUE;
  1284.         else
  1285.             m_bSqlSqQuantified = FALSE;
  1286.         longValue = SQLGetInfoLong(SQL_UNION);
  1287.         if (longValue & SQL_U_UNION)
  1288.             m_bSqlUUnion = TRUE;
  1289.         else
  1290.             m_bSqlUUnion = FALSE;
  1291.         if (longValue & SQL_U_UNION_ALL)
  1292.             m_bSqlUUnionAll = TRUE;
  1293.         else
  1294.             m_bSqlUUnionAll = FALSE;
  1295.  
  1296.         if (IsWindow(m_hWnd))
  1297.             UpdateData(FALSE);
  1298.     }
  1299. }
  1300.  
  1301. BOOL CSupportedSQL::OnInitDialog() 
  1302. {
  1303.     CPropertyPage::OnInitDialog();
  1304.     
  1305.     UpdateData(FALSE);
  1306.  
  1307.     return TRUE;  // return TRUE unless you set the focus to a control
  1308.                   // EXCEPTION: OCX Property Pages should return FALSE
  1309. }
  1310.  
  1311. /////////////////////////////////////////////////////////////////////////////
  1312. // CDataTypes property page
  1313.  
  1314. IMPLEMENT_DYNCREATE(CDataTypes, CPropertyPage)
  1315.  
  1316. CDataTypes::CDataTypes(CDatabase* pDatabase)
  1317.     : m_pGetTypeInfo(0),CMyPage(pDatabase,CDataTypes::IDD),
  1318.     m_pTypeDataHead(0),m_pTypeDataTail(0)
  1319. {
  1320.     //{{AFX_DATA_INIT(CDataTypes)
  1321.     m_strSqlType = _T("");
  1322.     m_strPrecision = _T("");
  1323.     m_strPrefixSuffix = _T("");
  1324.     m_strCreateParams = _T("");
  1325.     m_strNullable = _T("");
  1326.     m_strCaseSensitive = _T("");
  1327.     m_strSearchable = _T("");
  1328.     m_strMoney = _T("");
  1329.     m_strUnsigned = _T("");
  1330.     m_strAutoIncrement = _T("");
  1331.     m_strMaximumScale = _T("");
  1332.     m_strMinimumScale = _T("");
  1333.     //}}AFX_DATA_INIT
  1334. }
  1335.  
  1336. CDataTypes::~CDataTypes()
  1337. {
  1338.     if (m_pGetTypeInfo)
  1339.     {
  1340.         if (m_pGetTypeInfo->IsOpen())
  1341.             m_pGetTypeInfo->Close();
  1342.         delete m_pGetTypeInfo;
  1343.     }
  1344.  
  1345.     // delete type data list
  1346.     TYPEDATA*    p1 = m_pTypeDataHead;
  1347.     TYPEDATA*    p2;
  1348.     while (p1)
  1349.     {
  1350.         p2 = p1;
  1351.         p1 = p1->pNext;
  1352.         delete p2;
  1353.     }
  1354. }
  1355.  
  1356. void CDataTypes::DumpToFile(CStdioFile& file)
  1357. {
  1358.     if (m_pDatabase->IsOpen())
  1359.     {
  1360.         CString    string;
  1361.         CString    workString;
  1362.         SDWORD    value;
  1363.  
  1364.         file.WriteString(_T("Data Types\n----------\n\n"));
  1365.         file.WriteString(_T("Native type         SQL Type          Precision   Min Scale  Max Scale\n"));
  1366.         file.WriteString(_T("-----------         --------          ---------   ---------  ---------\n"));
  1367.         if (m_pGetTypeInfo)
  1368.         {
  1369.             if (m_pGetTypeInfo->IsOpen())
  1370.                 m_pGetTypeInfo->Close();
  1371.             delete m_pGetTypeInfo;
  1372.         }
  1373.  
  1374.         m_pGetTypeInfo = new CGetTypeInfo(m_pDatabase);
  1375.         m_pGetTypeInfo->Open();
  1376.  
  1377.         while (!m_pGetTypeInfo->IsEOF())
  1378.         {
  1379.             string = m_pGetTypeInfo->m_strTypeName;
  1380.             while (string.GetLength() < 20)
  1381.                 string += ' ';
  1382.             switch (m_pGetTypeInfo->m_fDataType)
  1383.             {
  1384.             case SQL_BIGINT:
  1385.                 string += _T("SQL_BIGINT        ");
  1386.                 break;
  1387.             case SQL_BINARY:
  1388.                 string += _T("SQL_BINARY        ");
  1389.                 break;
  1390.             case SQL_BIT:
  1391.                 string += _T("SQL_BIT           ");
  1392.                 break;
  1393.             case SQL_CHAR:
  1394.                 string += _T("SQL_CHAR          ");
  1395.                 break;
  1396.             case SQL_DATE:
  1397.                 string += _T("SQL_DATE          ");
  1398.                 break;
  1399.             case SQL_DECIMAL:
  1400.                 string += _T("SQL_DECIMAL       ");
  1401.                 break;
  1402.             case SQL_DOUBLE:
  1403.                 string += _T("SQL_DOUBLE        ");
  1404.                 break;
  1405.             case SQL_FLOAT:
  1406.                 string += _T("SQL_FLOAT         ");
  1407.                 break;
  1408.             case SQL_INTEGER:
  1409.                 string += _T("SQL_INTEGER       ");
  1410.                 break;
  1411.             case SQL_LONGVARBINARY:
  1412.                 string += _T("SQL_LONGVARBINARY ");
  1413.                 break;
  1414.             case SQL_LONGVARCHAR:
  1415.                 string += _T("SQL_LONGVARCHAR   ");
  1416.                 break;
  1417.             case SQL_NUMERIC:
  1418.                 string += _T("SQL_NUMERIC       ");
  1419.                 break;
  1420.             case SQL_REAL:
  1421.                 string += _T("SQL_REAL          ");
  1422.                 break;
  1423.             case SQL_SMALLINT:
  1424.                 string += _T("SQL_SMALLINT      ");
  1425.                 break;
  1426.             case SQL_TIME:
  1427.                 string += _T("SQL_TIME          ");
  1428.                 break;
  1429.             case SQL_TIMESTAMP:
  1430.                 string += _T("SQL_TIMESTAMP     ");
  1431.                 break;
  1432.             case SQL_TINYINT:
  1433.                 string += _T("SQL_TINYINT       ");
  1434.                 break;
  1435.             case SQL_VARBINARY:
  1436.                 string += _T("SQL_VARBINARY     ");
  1437.                 break;
  1438.             case SQL_VARCHAR:
  1439.                 string += _T("SQL_VARCHAR       ");
  1440.                 break;
  1441.             default:
  1442.                 string += _T("<unknown type>    ");
  1443.                 break;
  1444.             }
  1445.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_nPrecision)))
  1446.                 string += _T("<n/a>       ");
  1447.             else
  1448.             {
  1449.                 workString.Format(_T("%-11d "),m_pGetTypeInfo->m_nPrecision);
  1450.                 string += workString;
  1451.             }
  1452.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_nMinimumScale)))
  1453.                 string += _T("<n/a>      ");
  1454.             else
  1455.             {
  1456.                 workString.Format(_T("%-5d      "),m_pGetTypeInfo->m_nMinimumScale);
  1457.                 string += workString;
  1458.             }
  1459.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_nMaximumScale)))
  1460.             
  1461.                 string += _T("<n/a>      \n");
  1462.             else
  1463.             {
  1464.                 workString.Format(_T("%-5d\n"),m_pGetTypeInfo->m_nMaximumScale);
  1465.                 string += workString;
  1466.             }
  1467.  
  1468.             file.WriteString(string);
  1469.  
  1470.             m_pGetTypeInfo->MoveNext();
  1471.         }
  1472.         file.WriteString(_T("\n"));
  1473.         m_pGetTypeInfo->Close();
  1474.         delete m_pGetTypeInfo;
  1475.  
  1476.         file.WriteString(_T("Native type         Nullable  Unsigned  Auto Inc  Money  Case Sensitive\n"));
  1477.         file.WriteString(_T("-----------         --------  --------  --------  -----  --------------\n"));
  1478.         m_pGetTypeInfo = new CGetTypeInfo(m_pDatabase);
  1479.         m_pGetTypeInfo->Open();
  1480.  
  1481.         while (!m_pGetTypeInfo->IsEOF())
  1482.         {
  1483.             string = m_pGetTypeInfo->m_strTypeName;
  1484.             while (string.GetLength() < 20)
  1485.                 string += ' ';
  1486.             switch (m_pGetTypeInfo->m_fNullable)
  1487.             {
  1488.             case SQL_NO_NULLS:
  1489.                 string += _T("No        ");
  1490.                 break;
  1491.             case SQL_NULLABLE:
  1492.                 string += _T("Yes       ");
  1493.                 break;
  1494.             case SQL_NULLABLE_UNKNOWN:
  1495.             default:
  1496.                 string += _T("Unknown   ");
  1497.                 break;
  1498.             }
  1499.  
  1500.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_fUnsignedAttribute)))
  1501.                 string += _T("<n/a>     ");
  1502.             else if (m_pGetTypeInfo->m_fUnsignedAttribute)
  1503.                 string += _T("Yes       ");
  1504.             else
  1505.                 string += _T("No        ");
  1506.             
  1507.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_fAutoIncrement)))
  1508.                 string += _T("<n/a>     ");
  1509.             else if (m_pGetTypeInfo->m_fAutoIncrement)
  1510.                 string += _T("Yes       ");
  1511.             else
  1512.                 string += _T("No        ");
  1513.  
  1514.             if (m_pGetTypeInfo->m_bMoney)
  1515.                 string += _T("Yes    ");
  1516.             else
  1517.                 string += _T("No     ");
  1518.  
  1519.             if (m_pGetTypeInfo->m_bCaseSensitive)
  1520.                 string += _T("Yes\n");
  1521.             else
  1522.                 string += _T("No\n");
  1523.  
  1524.             file.WriteString(string);
  1525.             
  1526.             m_pGetTypeInfo->MoveNext();
  1527.         }
  1528.         file.WriteString(_T("\n"));
  1529.         m_pGetTypeInfo->Close();
  1530.         delete m_pGetTypeInfo;
  1531.         
  1532.         file.WriteString(_T("Native type         Lit. Prefix,Suffix  Create Params    Searchable\n"));
  1533.         file.WriteString(_T("-----------         ------------------  -------------    ----------\n"));
  1534.         m_pGetTypeInfo = new CGetTypeInfo(m_pDatabase);
  1535.         m_pGetTypeInfo->Open();
  1536.  
  1537.         while (!m_pGetTypeInfo->IsEOF())
  1538.         {
  1539.             string = m_pGetTypeInfo->m_strTypeName;
  1540.             while (string.GetLength() < 20)
  1541.                 string += ' ';
  1542.  
  1543.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_strLiteralPrefix)))
  1544.                 workString = _T("<n/a>");
  1545.             else
  1546.                 workString = m_pGetTypeInfo->m_strLiteralPrefix;
  1547.             workString += ',';
  1548.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_strLiteralSuffix)))
  1549.                 workString += _T("<n/a>");
  1550.             else
  1551.                 workString += m_pGetTypeInfo->m_strLiteralSuffix;
  1552.             while (workString.GetLength() < 20)
  1553.                 workString += ' ';
  1554.             string += workString;
  1555.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_strCreateParams)))
  1556.                 string += _T("<none>           ");
  1557.             else
  1558.             {
  1559.                 workString = m_pGetTypeInfo->m_strCreateParams;
  1560.                 while (workString.GetLength() < 17)
  1561.                     workString += ' ';
  1562.                 string += workString;
  1563.             }
  1564.             switch (m_pGetTypeInfo->m_fSearchable)
  1565.             {
  1566.             case SQL_UNSEARCHABLE:
  1567.                 string += _T("No\n");
  1568.                 break;
  1569.             case SQL_LIKE_ONLY:
  1570.                 string += _T("Only with LIKE\n");
  1571.                 break;
  1572.             case SQL_ALL_EXCEPT_LIKE:
  1573.                 string += _T("with all except LIKE\n");
  1574.                 break;
  1575.             case SQL_SEARCHABLE:
  1576.                 string += _T("Yes\n");
  1577.                 break;
  1578.             }
  1579.  
  1580.             file.WriteString(string);
  1581.             
  1582.             m_pGetTypeInfo->MoveNext();
  1583.         }
  1584.         file.WriteString(_T("\n"));
  1585.         m_pGetTypeInfo->Close();
  1586.         delete m_pGetTypeInfo;
  1587.  
  1588.         file.WriteString(_T("Native type         Convert() Conversions\n"));
  1589.         file.WriteString(_T("-----------         ---------------------\n"));
  1590.         m_pGetTypeInfo = new CGetTypeInfo(m_pDatabase);
  1591.         m_pGetTypeInfo->Open();
  1592.  
  1593.         while (!m_pGetTypeInfo->IsEOF())
  1594.         {
  1595.             string = m_pGetTypeInfo->m_strTypeName;
  1596.             while (string.GetLength() < 20)
  1597.                 string += ' ';
  1598.             
  1599.             switch (m_pGetTypeInfo->m_fDataType)
  1600.             {
  1601.             case SQL_BIGINT:
  1602.                 value = SQLGetInfoLong(SQL_CONVERT_BIGINT);
  1603.                 break;
  1604.             case SQL_BINARY:
  1605.                 value = SQLGetInfoLong(SQL_CONVERT_BINARY);
  1606.                 break;
  1607.             case SQL_BIT:
  1608.                 value = SQLGetInfoLong(SQL_CONVERT_BIT);
  1609.                 break;
  1610.             case SQL_CHAR:
  1611.                 value = SQLGetInfoLong(SQL_CONVERT_CHAR);
  1612.                 break;
  1613.             case SQL_DATE:
  1614.                 value = SQLGetInfoLong(SQL_CONVERT_DATE);
  1615.                 break;
  1616.             case SQL_DECIMAL:
  1617.                 value = SQLGetInfoLong(SQL_CONVERT_DECIMAL);
  1618.                 break;
  1619.             case SQL_DOUBLE:
  1620.                 value = SQLGetInfoLong(SQL_CONVERT_DOUBLE);
  1621.                 break;
  1622.             case SQL_FLOAT:
  1623.                 value = SQLGetInfoLong(SQL_CONVERT_FLOAT);
  1624.                 break;
  1625.             case SQL_INTEGER:
  1626.                 value = SQLGetInfoLong(SQL_CONVERT_INTEGER);
  1627.                 break;
  1628.             case SQL_LONGVARBINARY:
  1629.                 value = SQLGetInfoLong(SQL_CONVERT_LONGVARBINARY);
  1630.                 break;
  1631.             case SQL_LONGVARCHAR:
  1632.                 value = SQLGetInfoLong(SQL_CONVERT_LONGVARCHAR);
  1633.                 break;
  1634.             case SQL_NUMERIC:
  1635.                 value = SQLGetInfoLong(SQL_CONVERT_NUMERIC);
  1636.                 break;
  1637.             case SQL_REAL:
  1638.                 value = SQLGetInfoLong(SQL_CONVERT_REAL);
  1639.                 break;
  1640.             case SQL_SMALLINT:
  1641.                 value = SQLGetInfoLong(SQL_CONVERT_SMALLINT);
  1642.                 break;
  1643.             case SQL_TIME:
  1644.                 value = SQLGetInfoLong(SQL_CONVERT_TIME);
  1645.                 break;
  1646.             case SQL_TIMESTAMP:
  1647.                 value = SQLGetInfoLong(SQL_CONVERT_TIMESTAMP);
  1648.                 break;
  1649.             case SQL_TINYINT:
  1650.                 value = SQLGetInfoLong(SQL_CONVERT_TINYINT);
  1651.                 break;
  1652.             case SQL_VARBINARY:
  1653.                 value = SQLGetInfoLong(SQL_CONVERT_VARBINARY);
  1654.                 break;
  1655.             case SQL_VARCHAR:
  1656.                 value = SQLGetInfoLong(SQL_CONVERT_VARCHAR);
  1657.                 break;
  1658.             default:
  1659.                 value = 0;
  1660.                 break;
  1661.             }
  1662.             if (!value)
  1663.                 string += _T("<none>");
  1664.             else
  1665.             {
  1666.                 BOOL    b = FALSE;
  1667.                 PrintConversions(b,value,SQL_CVT_BIGINT,string,_T("SQL_BIGINT"),file);
  1668.                 PrintConversions(b,value,SQL_CVT_BINARY,string,_T("SQL_BINARY"),file);
  1669.                 PrintConversions(b,value,SQL_CVT_BIT,string,_T("SQL_BIT"),file);
  1670.                 PrintConversions(b,value,SQL_CVT_CHAR,string,_T("SQL_CHAR"),file);
  1671.                 PrintConversions(b,value,SQL_CVT_DATE,string,_T("SQL_DATE"),file);
  1672.                 PrintConversions(b,value,SQL_CVT_DECIMAL,string,_T("SQL_DECIMAL"),file);
  1673.                 PrintConversions(b,value,SQL_CVT_DOUBLE,string,_T("SQL_DOUBLE"),file);
  1674.                 PrintConversions(b,value,SQL_CVT_FLOAT,string,_T("SQL_FLOAT"),file);
  1675.                 PrintConversions(b,value,SQL_CVT_INTEGER,string,_T("SQL_INTEGER"),file);
  1676.                 PrintConversions(b,value,SQL_CVT_LONGVARBINARY,string,_T("SQL_LONGVARBINARY"),file);
  1677.                 PrintConversions(b,value,SQL_CVT_LONGVARCHAR,string,_T("SQL_LONGVARCHAR"),file);
  1678.                 PrintConversions(b,value,SQL_CVT_NUMERIC,string,_T("SQL_NUMERIC"),file);
  1679.                 PrintConversions(b,value,SQL_CVT_REAL,string,_T("SQL_REAL"),file);
  1680.                 PrintConversions(b,value,SQL_CVT_SMALLINT,string,_T("SQL_SMALLINT"),file);
  1681.                 PrintConversions(b,value,SQL_CVT_TIME,string,_T("SQL_TIME"),file);
  1682.                 PrintConversions(b,value,SQL_CVT_TIMESTAMP,string,_T("SQL_TIMESTAMP"),file);
  1683.                 PrintConversions(b,value,SQL_CVT_TINYINT,string,_T("SQL_TINYINT"),file);
  1684.                 PrintConversions(b,value,SQL_CVT_VARBINARY,string,_T("SQL_VARBINARY"),file);
  1685.                 PrintConversions(b,value,SQL_CVT_VARCHAR,string,_T("SQL_VARCHAR"),file);
  1686.             }
  1687.             string += _T("\n\n");
  1688.  
  1689.             file.WriteString(string);
  1690.             
  1691.             m_pGetTypeInfo->MoveNext();
  1692.         }
  1693.         file.WriteString(_T("\n"));
  1694.         m_pGetTypeInfo->Close();
  1695.  
  1696.         delete m_pGetTypeInfo;
  1697.         m_pGetTypeInfo = 0;
  1698.         file.WriteString(_T("\n"));
  1699.  
  1700.     }
  1701. }
  1702.  
  1703. void CDataTypes::PrintConversions(BOOL& flag,SDWORD value,SDWORD mask,
  1704.                       CString& string,const CString& strType,CStdioFile& file)
  1705. {
  1706.     CString    workString;
  1707.     if (value & mask)
  1708.     {
  1709.         if (string.GetLength() + strType.GetLength() > 75)
  1710.         {
  1711.             string += _T("\n");
  1712.             file.WriteString(string);
  1713.             string = _T("                    ") + strType;
  1714.         }
  1715.         else
  1716.         {
  1717.             if (flag)
  1718.                 string += _T(",");
  1719.             string += strType;
  1720.         }
  1721.         flag = TRUE;
  1722.     }
  1723. }
  1724.  
  1725. void CDataTypes::DoDataExchange(CDataExchange* pDX)
  1726. {
  1727.     CPropertyPage::DoDataExchange(pDX);
  1728.     //{{AFX_DATA_MAP(CDataTypes)
  1729.     DDX_Control(pDX, IDC_CONVERSIONS, m_lbConversions);
  1730.     DDX_Control(pDX, IDC_DATA_TYPE_LIST, m_lbDataTypes);
  1731.     DDX_Text(pDX, IDC_SQL_TYPE, m_strSqlType);
  1732.     DDX_Text(pDX, IDC_PRECISION, m_strPrecision);
  1733.     DDX_Text(pDX, IDD_PREFIX_SUFFIX, m_strPrefixSuffix);
  1734.     DDX_Text(pDX, IDD_CREATE_PARAMS, m_strCreateParams);
  1735.     DDX_Text(pDX, IDC_NULLABLE, m_strNullable);
  1736.     DDX_Text(pDX, IDC_CASE_SENSITIVE, m_strCaseSensitive);
  1737.     DDX_Text(pDX, IDC_SEARCHABLE, m_strSearchable);
  1738.     DDX_Text(pDX, IDC_MONEY, m_strMoney);
  1739.     DDX_Text(pDX, IDC_UNSIGNED, m_strUnsigned);
  1740.     DDX_Text(pDX, IDC_AUTO_INCREMENT, m_strAutoIncrement);
  1741.     DDX_Text(pDX, IDC_MAXIMUM_SCALE, m_strMaximumScale);
  1742.     DDX_Text(pDX, IDC_MINIMUM_SCALE, m_strMinimumScale);
  1743.     //}}AFX_DATA_MAP
  1744. }
  1745.  
  1746.  
  1747. BEGIN_MESSAGE_MAP(CDataTypes, CPropertyPage)
  1748.     //{{AFX_MSG_MAP(CDataTypes)
  1749.     ON_LBN_SELCHANGE(IDC_DATA_TYPE_LIST, OnSelchangeDataTypeList)
  1750.     //}}AFX_MSG_MAP
  1751. END_MESSAGE_MAP()
  1752.  
  1753. /////////////////////////////////////////////////////////////////////////////
  1754. // CDataTypes message handlers
  1755.  
  1756. void CDataTypes::OnNewDSN()
  1757. {
  1758.     if (IsWindow(m_hWnd) && m_pDatabase->IsOpen())
  1759.     {
  1760.         if (m_pGetTypeInfo)
  1761.         {
  1762.             if (m_pGetTypeInfo->IsOpen())
  1763.                 m_pGetTypeInfo->Close();
  1764.             delete m_pGetTypeInfo;
  1765.         }
  1766.  
  1767.         // delete type data list
  1768.         TYPEDATA*    p1 = m_pTypeDataHead;
  1769.         TYPEDATA*    p2;
  1770.         while (p1)
  1771.         {
  1772.             p2 = p1;
  1773.             p1 = p1->pNext;
  1774.             delete p2;
  1775.         }
  1776.         m_pTypeDataHead = m_pTypeDataTail = 0;
  1777.  
  1778.         m_lbDataTypes.ResetContent();
  1779.         m_pGetTypeInfo = new CGetTypeInfo(m_pDatabase);
  1780.         m_pGetTypeInfo->Open();
  1781.         while (!m_pGetTypeInfo->IsEOF())
  1782.         {
  1783.             TYPEDATA*    pTypeData = new TYPEDATA;
  1784.             pTypeData->strTypeName = m_pGetTypeInfo->m_strTypeName;
  1785.             pTypeData->nSqlType = m_pGetTypeInfo->m_fDataType;
  1786.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_nPrecision)))
  1787.                 pTypeData->nPrecision = -1;
  1788.             else
  1789.                 pTypeData->nPrecision = m_pGetTypeInfo->m_nPrecision;
  1790.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_strLiteralPrefix)))
  1791.                 pTypeData->strLiteralPrefix = "";
  1792.             else
  1793.                 pTypeData->strLiteralPrefix = m_pGetTypeInfo->m_strLiteralPrefix;
  1794.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_strLiteralSuffix)))
  1795.                 pTypeData->strLiteralSuffix = "";
  1796.             else
  1797.                 pTypeData->strLiteralSuffix = m_pGetTypeInfo->m_strLiteralSuffix;
  1798.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_strCreateParams)))
  1799.                 pTypeData->strCreateParams = "";
  1800.             else
  1801.                 pTypeData->strCreateParams = m_pGetTypeInfo->m_strCreateParams;
  1802.             pTypeData->nNullable = m_pGetTypeInfo->m_fNullable;
  1803.             pTypeData->bCaseSensitive = m_pGetTypeInfo->m_bCaseSensitive;
  1804.             pTypeData->nSearchable = m_pGetTypeInfo->m_fSearchable;
  1805.             if (m_pGetTypeInfo->IsFieldNull(
  1806.                 &(m_pGetTypeInfo->m_fUnsignedAttribute)))
  1807.             {
  1808.                 pTypeData->nUnsigned = -1;
  1809.             }
  1810.             else if (m_pGetTypeInfo->m_fUnsignedAttribute)
  1811.                 pTypeData->nUnsigned = 1;
  1812.             else
  1813.                 pTypeData->nUnsigned = 0;
  1814.             pTypeData->bMoney = m_pGetTypeInfo->m_bMoney;
  1815.             if (m_pGetTypeInfo->IsFieldNull(
  1816.                 &(m_pGetTypeInfo->m_fAutoIncrement)))
  1817.             {
  1818.                 pTypeData->nAutoIncrement = -1;
  1819.             }
  1820.             else if (m_pGetTypeInfo->m_fAutoIncrement)
  1821.                 pTypeData->nAutoIncrement = 1;
  1822.             else
  1823.                 pTypeData->nAutoIncrement = 0;
  1824.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_nMinimumScale)))
  1825.                 pTypeData->nMinimumScale = -1;
  1826.             else
  1827.                 pTypeData->nMinimumScale = m_pGetTypeInfo->m_nMinimumScale;
  1828.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_nMaximumScale)))
  1829.                 pTypeData->nMaximumScale = -1;
  1830.             else
  1831.                 pTypeData->nMaximumScale = m_pGetTypeInfo->m_nMaximumScale;
  1832.  
  1833.             pTypeData->pNext = 0;
  1834.             InsertTypeData(pTypeData);
  1835.             m_lbDataTypes.AddString(m_pGetTypeInfo->m_strTypeName);
  1836.             m_pGetTypeInfo->MoveNext();
  1837.         }
  1838.         m_pGetTypeInfo->Close();
  1839.         delete m_pGetTypeInfo;
  1840.         m_pGetTypeInfo = 0;
  1841.  
  1842.         if (m_lbDataTypes.GetCount())
  1843.         {
  1844.             m_lbDataTypes.SetCurSel(0);
  1845.             OnSelchangeDataTypeList();
  1846.         }
  1847.     }
  1848. }
  1849.  
  1850. void CDataTypes::InsertTypeData(TYPEDATA* pTypeData)
  1851. {
  1852.     TYPEDATA*    p1 = m_pTypeDataTail;
  1853.     if (!p1)
  1854.         m_pTypeDataHead = m_pTypeDataTail = pTypeData;
  1855.     else
  1856.     {
  1857.         p1->pNext = pTypeData;
  1858.         m_pTypeDataTail = pTypeData;
  1859.     }
  1860. }
  1861.  
  1862. BOOL CDataTypes::OnInitDialog() 
  1863. {
  1864.     CPropertyPage::OnInitDialog();
  1865.     
  1866.     OnNewDSN();
  1867.     
  1868.     return TRUE;  // return TRUE unless you set the focus to a control
  1869.                   // EXCEPTION: OCX Property Pages should return FALSE
  1870. }
  1871.  
  1872. void CDataTypes::OnSelchangeDataTypeList() 
  1873. {
  1874.     if (m_pTypeDataHead)
  1875.     {
  1876.         CString    string;
  1877.         m_lbDataTypes.GetText(m_lbDataTypes.GetCurSel(),string);
  1878.  
  1879.         TYPEDATA* pTypeData = m_pTypeDataHead;
  1880.         while (pTypeData)
  1881.         {
  1882.             if (pTypeData->strTypeName == string)
  1883.                 break;
  1884.             pTypeData = pTypeData->pNext;
  1885.         }
  1886.         if (pTypeData)
  1887.         {
  1888.             // note: table lookup would be bettter here
  1889.             switch (pTypeData->nSqlType)
  1890.             {
  1891.             case SQL_BIGINT:
  1892.                 m_strSqlType = _T("SQL_BIGINT");
  1893.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_BIGINT));
  1894.                 break;
  1895.             case SQL_BINARY:
  1896.                 m_strSqlType = _T("SQL_BINARY");
  1897.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_BINARY));
  1898.                 break;
  1899.             case SQL_BIT:
  1900.                 m_strSqlType = _T("SQL_BIT");
  1901.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_BIT));
  1902.                 break;
  1903.             case SQL_CHAR:
  1904.                 m_strSqlType = _T("SQL_CHAR");
  1905.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_CHAR));
  1906.                 break;
  1907.             case SQL_DATE:
  1908.                 m_strSqlType = _T("SQL_DATE");
  1909.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_DATE));
  1910.                 break;
  1911.             case SQL_DECIMAL:
  1912.                 m_strSqlType = _T("SQL_DECIMAL");
  1913.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_DECIMAL));
  1914.                 break;
  1915.             case SQL_DOUBLE:
  1916.                 m_strSqlType = _T("SQL_DOUBLE");
  1917.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_DOUBLE));
  1918.                 break;
  1919.             case SQL_FLOAT:
  1920.                 m_strSqlType = _T("SQL_FLOAT");
  1921.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_FLOAT));
  1922.                 break;
  1923.             case SQL_INTEGER:
  1924.                 m_strSqlType = _T("SQL_INTEGER");
  1925.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_INTEGER));
  1926.                 break;
  1927.             case SQL_LONGVARBINARY:
  1928.                 m_strSqlType = _T("SQL_LONGVARBINARY");
  1929.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_LONGVARBINARY));
  1930.                 break;
  1931.             case SQL_LONGVARCHAR:
  1932.                 m_strSqlType = _T("SQL_LONGVARCHAR");
  1933.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_LONGVARCHAR));
  1934.                 break;
  1935.             case SQL_NUMERIC:
  1936.                 m_strSqlType = _T("SQL_NUMERIC");
  1937.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_NUMERIC));
  1938.                 break;
  1939.             case SQL_REAL:
  1940.                 m_strSqlType = _T("SQL_REAL");
  1941.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_REAL));
  1942.                 break;
  1943.             case SQL_SMALLINT:
  1944.                 m_strSqlType = _T("SQL_SMALLINT");
  1945.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_SMALLINT));
  1946.                 break;
  1947.             case SQL_TIME:
  1948.                 m_strSqlType = _T("SQL_TIME");
  1949.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_TIME));
  1950.                 break;
  1951.             case SQL_TIMESTAMP:
  1952.                 m_strSqlType = _T("SQL_TIMESTAMP");
  1953.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_TIMESTAMP));
  1954.                 break;
  1955.             case SQL_TINYINT:
  1956.                 m_strSqlType = _T("SQL_TINYINT");
  1957.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_TINYINT));
  1958.                 break;
  1959.             case SQL_VARBINARY:
  1960.                 m_strSqlType = _T("SQL_VARBINARY");
  1961.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_VARBINARY));
  1962.                 break;
  1963.             case SQL_VARCHAR:
  1964.                 m_strSqlType = _T("SQL_VARCHAR");
  1965.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_VARCHAR));
  1966.                 break;
  1967.             default:
  1968.                 m_strSqlType = _T("<new or driver-specific type>");
  1969.                 ShowConversions(0);
  1970.                 break;
  1971.             }
  1972.             if (pTypeData->nPrecision == -1)
  1973.                 m_strPrecision = _T("<n/a>");
  1974.             else
  1975.                 m_strPrecision.Format("%d",pTypeData->nPrecision);
  1976.             if (pTypeData->strLiteralPrefix == "")
  1977.                 m_strPrefixSuffix = _T("<n/a>");
  1978.             else
  1979.                 m_strPrefixSuffix = pTypeData->strLiteralPrefix;
  1980.             m_strPrefixSuffix += ",";
  1981.             if (pTypeData->strLiteralSuffix == "")
  1982.                 m_strPrefixSuffix += _T("<n/a>");
  1983.             else
  1984.                 m_strPrefixSuffix += pTypeData->strLiteralSuffix;
  1985.             if (pTypeData->strCreateParams == "")
  1986.                 m_strCreateParams = _T("<none>");
  1987.             else
  1988.                 m_strCreateParams = pTypeData->strCreateParams;
  1989.             switch (pTypeData->nNullable)
  1990.             {
  1991.             case SQL_NO_NULLS:
  1992.                 m_strNullable = _T("No");
  1993.                 break;
  1994.             case SQL_NULLABLE:
  1995.                 m_strNullable = _T("Yes");
  1996.                 break;
  1997.             case SQL_NULLABLE_UNKNOWN:
  1998.                 m_strNullable = _T("Unknown");
  1999.                 break;
  2000.             }
  2001.             if (pTypeData->bCaseSensitive)
  2002.                 m_strCaseSensitive = _T("Yes");
  2003.             else
  2004.                 m_strCaseSensitive = _T("No");
  2005.  
  2006.             switch (pTypeData->nSearchable)
  2007.             {
  2008.             case SQL_UNSEARCHABLE:
  2009.                 m_strSearchable = _T("No");
  2010.                 break;
  2011.             case SQL_LIKE_ONLY:
  2012.                 m_strSearchable = _T("Only with LIKE");
  2013.                 break;
  2014.             case SQL_ALL_EXCEPT_LIKE:
  2015.                 m_strSearchable = _T("with all except LIKE");
  2016.                 break;
  2017.             case SQL_SEARCHABLE:
  2018.                 m_strSearchable = _T("Yes");
  2019.                 break;
  2020.             }
  2021.  
  2022.             switch (pTypeData->nUnsigned)
  2023.             {
  2024.             case -1:
  2025.                 m_strUnsigned = _T("<n/a>");
  2026.                 break;
  2027.             case 0:
  2028.                 m_strUnsigned = _T("No");
  2029.                 break;
  2030.             case 1:
  2031.                 m_strUnsigned = _T("Yes");
  2032.                 break;
  2033.             }
  2034.  
  2035.             if (pTypeData->bMoney)
  2036.                 m_strMoney = _T("Yes");
  2037.             else
  2038.                 m_strMoney = _T("No");
  2039.  
  2040.             switch (pTypeData->nAutoIncrement)
  2041.             {
  2042.             case -1:
  2043.                 m_strAutoIncrement = _T("<n/a>");
  2044.                 break;
  2045.             case 0:
  2046.                 m_strAutoIncrement = _T("No");
  2047.                 break;
  2048.             case 1:
  2049.                 m_strAutoIncrement = _T("Yes");
  2050.                 break;
  2051.             }
  2052.  
  2053.             if (pTypeData->nMinimumScale == -1)
  2054.                 m_strMinimumScale = _T("<n/a>");
  2055.             else
  2056.                 m_strMinimumScale.Format(_T("%d"),pTypeData->nMinimumScale);
  2057.  
  2058.             if (pTypeData->nMaximumScale == -1)
  2059.                 m_strMaximumScale = _T("<n/a>");
  2060.             else
  2061.                 m_strMaximumScale.Format(_T("%d"),pTypeData->nMaximumScale);
  2062.  
  2063.         }
  2064.         else
  2065.             m_strSqlType = _T("<n/a>?");
  2066.     }
  2067.     else
  2068.         m_strSqlType = _T("<n/a>");
  2069.  
  2070.     UpdateData(FALSE);
  2071. }
  2072.  
  2073. void CDataTypes::ShowConversions(SDWORD dwDataType)
  2074. {
  2075.     m_lbConversions.ResetContent();
  2076.     if (!dwDataType)
  2077.         m_lbConversions.AddString(_T("<none>"));
  2078.     else
  2079.     {
  2080.         if (dwDataType & SQL_CVT_BIGINT)
  2081.             m_lbConversions.AddString(_T("SQL_BIGINT"));
  2082.         if (dwDataType & SQL_CVT_BINARY)
  2083.             m_lbConversions.AddString(_T("SQL_BINARY"));
  2084.         if (dwDataType & SQL_CVT_BIT)
  2085.             m_lbConversions.AddString(_T("SQL_BIT"));
  2086.         if (dwDataType & SQL_CVT_CHAR)
  2087.             m_lbConversions.AddString(_T("SQL_CHAR"));
  2088.         if (dwDataType & SQL_CVT_DATE)
  2089.             m_lbConversions.AddString(_T("SQL_DATE"));
  2090.         if (dwDataType & SQL_CVT_DECIMAL)
  2091.             m_lbConversions.AddString(_T("SQL_DECIMAL"));
  2092.         if (dwDataType & SQL_CVT_DOUBLE)
  2093.             m_lbConversions.AddString(_T("SQL_DOUBLE"));
  2094.         if (dwDataType & SQL_CVT_FLOAT)
  2095.             m_lbConversions.AddString(_T("SQL_FLOAT"));
  2096.         if (dwDataType & SQL_CVT_INTEGER)
  2097.             m_lbConversions.AddString(_T("SQL_INTEGER"));
  2098.         if (dwDataType & SQL_CVT_LONGVARBINARY)
  2099.             m_lbConversions.AddString(_T("SQL_LONGVARBINARY"));
  2100.         if (dwDataType & SQL_CVT_LONGVARCHAR)
  2101.             m_lbConversions.AddString(_T("SQL_LONGVARCHAR"));
  2102.         if (dwDataType & SQL_CVT_NUMERIC)
  2103.             m_lbConversions.AddString(_T("SQL_NUMERIC"));
  2104.         if (dwDataType & SQL_CVT_REAL)
  2105.             m_lbConversions.AddString(_T("SQL_REAL"));
  2106.         if (dwDataType & SQL_CVT_SMALLINT)
  2107.             m_lbConversions.AddString(_T("SQL_SMALLINT"));
  2108.         if (dwDataType & SQL_CVT_TIME)
  2109.             m_lbConversions.AddString(_T("SQL_TIME"));
  2110.         if (dwDataType & SQL_CVT_TIMESTAMP)
  2111.             m_lbConversions.AddString(_T("SQL_TIMESTAMP"));
  2112.         if (dwDataType & SQL_CVT_TINYINT)
  2113.             m_lbConversions.AddString(_T("SQL_TINYINT"));
  2114.         if (dwDataType & SQL_CVT_VARBINARY)
  2115.             m_lbConversions.AddString(_T("SQL_VARBINARY"));
  2116.         if (dwDataType & SQL_CVT_VARCHAR)
  2117.             m_lbConversions.AddString(_T("SQL_VARCHAR"));
  2118.     }
  2119. }
  2120.  
  2121. /////////////////////////////////////////////////////////////////////////////
  2122. // CIdentifiers property page
  2123.  
  2124. IMPLEMENT_DYNCREATE(CIdentifiers, CPropertyPage)
  2125.  
  2126. CIdentifiers::CIdentifiers(CDatabase* pDatabase)
  2127.  : CMyPage(pDatabase,CIdentifiers::IDD)
  2128. {
  2129.     //{{AFX_DATA_INIT(CIdentifiers)
  2130.     m_strSqlIdentifierCase = _T("");
  2131.     m_strSqlIdentifierQuoteChar = _T("");
  2132.     m_strSqlOwnerTerm = _T("");
  2133.     m_strSqlProcedureTerm = _T("");
  2134.     m_strSqlQualifierLocation = _T("");
  2135.     m_strSqlQualifierNameSeparator = _T("");
  2136.     m_strSqlQualifierTerm = _T("");
  2137.     m_strSqlQuotedIdentifierCase = _T("");
  2138.     m_strSqlSearchPatternEscape = _T("");
  2139.     m_strSqlTableTerm = _T("");
  2140.     m_strSqlSpecialCharacters = _T("");
  2141.     //}}AFX_DATA_INIT
  2142.  
  2143.     OnNewDSN();
  2144. }
  2145.  
  2146. CIdentifiers::~CIdentifiers()
  2147. {
  2148. }
  2149.  
  2150. void CIdentifiers::DumpToFile(CStdioFile& file)
  2151. {
  2152.     if (m_pDatabase->IsOpen())
  2153.     {
  2154.         CString    bufferString;
  2155.         CString    string;
  2156.         CString    workString;
  2157.  
  2158.         file.WriteString(_T("Identifiers\n-----------\n\n"));
  2159.         file.WriteString(_T("Driver-Specific Keywords:\n-------------------------\n"));
  2160.  
  2161.         char    buffer[32000];
  2162.         SWORD    cbData;
  2163.         ::SQLGetInfo(m_pDatabase->m_hdbc,SQL_KEYWORDS,
  2164.             (PTR)buffer,32000,&cbData);
  2165.         bufferString = buffer;
  2166.         int        n;
  2167.         string = "";
  2168.         BOOL    b = FALSE;
  2169.         while ((n = bufferString.Find(',')) != -1)
  2170.         {
  2171.             workString = bufferString.Left(n);
  2172.             bufferString = bufferString.Right(bufferString.GetLength() - n - 1);
  2173.             if (string.GetLength() + workString.GetLength() > 75)
  2174.             {
  2175.                 string += _T("\n");
  2176.                 file.WriteString(string);
  2177.                 string = workString;
  2178.             }
  2179.             else
  2180.             {
  2181.                 if (b)
  2182.                     string += _T(",");
  2183.                 string += workString;
  2184.             }
  2185.             b = TRUE;
  2186.         }
  2187.         string += _T("\n\n");
  2188.         file.WriteString(string);
  2189.  
  2190.         string.Format(_T("          Identifier Case - %s\n"),m_strSqlIdentifierCase);
  2191.         file.WriteString(string);
  2192.         string.Format(_T("   Quoted Identifier Case - %s\n"),m_strSqlQuotedIdentifierCase);
  2193.         file.WriteString(string);
  2194.         string.Format(_T("    Search Pattern Escape - %s\n"),m_strSqlSearchPatternEscape);
  2195.         file.WriteString(string);
  2196.         string.Format(_T("    Identifier Quote Char - %s\n"),m_strSqlIdentifierQuoteChar);
  2197.         file.WriteString(string);
  2198.         string.Format(_T("       Qualifier Location - %s\n"),m_strSqlQualifierLocation);
  2199.         file.WriteString(string);
  2200.         string.Format(_T("      Qualifier Separator - %s\n"),m_strSqlQualifierNameSeparator);
  2201.         file.WriteString(string);
  2202.         string.Format(_T("               Owner Term - %s\n"),m_strSqlOwnerTerm);
  2203.         file.WriteString(string);
  2204.         string.Format(_T("           Procedure Term - %s\n"),m_strSqlProcedureTerm);
  2205.         file.WriteString(string);
  2206.         string.Format(_T("           Qualifier Term - %s\n"),m_strSqlQualifierTerm);
  2207.         file.WriteString(string);
  2208.         string.Format(_T("                TableTerm - %s\n\n"),m_strSqlTableTerm);
  2209.         file.WriteString(string);
  2210.  
  2211.         file.WriteString(_T("Special Characters:\n-------------------\n"));
  2212.         if (m_strSqlSpecialCharacters.GetLength() == 0)
  2213.             file.WriteString(_T("<none>\n\n"));
  2214.         else
  2215.         {
  2216.             string = m_strSqlSpecialCharacters;
  2217.             while (string.GetLength() > 75)
  2218.             {
  2219.                 workString = string.Left(75);
  2220.                 string = string.Right(string.GetLength() - n - 1);
  2221.                 workString += _T("\n");
  2222.                 file.WriteString(workString);
  2223.             }
  2224.             string += _T("\n");
  2225.             file.WriteString(string);
  2226.         }
  2227.         file.WriteString(_T("\n"));
  2228.     }
  2229. }
  2230.  
  2231. void CIdentifiers::DoDataExchange(CDataExchange* pDX)
  2232. {
  2233.     CPropertyPage::DoDataExchange(pDX);
  2234.     //{{AFX_DATA_MAP(CIdentifiers)
  2235.     DDX_Control(pDX, IDC_DRIVER_KEYWORDS, m_lbDriverKeywords);
  2236.     DDX_Control(pDX, IDC_ODBC_KEYWORDS, m_lbOdbcKeywords);
  2237.     DDX_Text(pDX, IDC_SQL_IDENTIFIER_CASE, m_strSqlIdentifierCase);
  2238.     DDX_Text(pDX, IDC_SQL_IDENTIFIER_QUOTE_CHAR, m_strSqlIdentifierQuoteChar);
  2239.     DDX_Text(pDX, IDC_SQL_OWNER_TERM, m_strSqlOwnerTerm);
  2240.     DDX_Text(pDX, IDC_SQL_PROCEDURE_TERM, m_strSqlProcedureTerm);
  2241.     DDX_Text(pDX, IDC_SQL_QUALIFIER_LOCATION, m_strSqlQualifierLocation);
  2242.     DDX_Text(pDX, IDC_SQL_QUALIFIER_NAME_SEPARATOR, m_strSqlQualifierNameSeparator);
  2243.     DDX_Text(pDX, IDC_SQL_QUALIFIER_TERM, m_strSqlQualifierTerm);
  2244.     DDX_Text(pDX, IDC_SQL_QUOTED_IDENTIFIER_CASE, m_strSqlQuotedIdentifierCase);
  2245.     DDX_Text(pDX, IDC_SQL_SEARCH_PATTERN_ESCAPE, m_strSqlSearchPatternEscape);
  2246.     DDX_Text(pDX, IDC_SQL_TABLE_TERM, m_strSqlTableTerm);
  2247.     DDX_Text(pDX, IDC_SQL_SPECIAL_CHARACTERS, m_strSqlSpecialCharacters);
  2248.     //}}AFX_DATA_MAP
  2249. }
  2250.  
  2251.  
  2252. BEGIN_MESSAGE_MAP(CIdentifiers, CPropertyPage)
  2253.     //{{AFX_MSG_MAP(CIdentifiers)
  2254.     //}}AFX_MSG_MAP
  2255. END_MESSAGE_MAP()
  2256.  
  2257. /////////////////////////////////////////////////////////////////////////////
  2258. // CIdentifiers message handlers
  2259.  
  2260. void CIdentifiers::OnNewDSN()
  2261. {
  2262.     if (m_pDatabase->IsOpen())
  2263.     {
  2264.         switch (SQLGetInfoShort(SQL_IDENTIFIER_CASE))
  2265.         {
  2266.         case SQL_IC_UPPER:
  2267.             m_strSqlIdentifierCase = _T("Upper");
  2268.             break;
  2269.         case SQL_IC_LOWER:
  2270.             m_strSqlIdentifierCase = _T("Lower");
  2271.             break;
  2272.         case SQL_IC_SENSITIVE:
  2273.             m_strSqlIdentifierCase = _T("Sensitive");
  2274.             break;
  2275.         case SQL_IC_MIXED:
  2276.             m_strSqlIdentifierCase = _T("Mixed");
  2277.             break;
  2278.         }
  2279.         m_strSqlIdentifierQuoteChar = SQLGetInfoString(SQL_IDENTIFIER_QUOTE_CHAR);
  2280.         m_strSqlOwnerTerm = SQLGetInfoString(SQL_OWNER_TERM);
  2281.         m_strSqlProcedureTerm = SQLGetInfoString(SQL_PROCEDURE_TERM);
  2282.         switch (SQLGetInfoShort(SQL_QUALIFIER_LOCATION))
  2283.         {
  2284.         case SQL_QL_START:
  2285.             m_strSqlQualifierLocation = _T("Start");
  2286.             break;
  2287.         case SQL_QL_END:
  2288.             m_strSqlQualifierLocation = _T("End");
  2289.             break;
  2290.         }
  2291.         m_strSqlQualifierNameSeparator = SQLGetInfoString(SQL_QUALIFIER_NAME_SEPARATOR);
  2292.         m_strSqlQualifierTerm = SQLGetInfoString(SQL_QUALIFIER_TERM);
  2293.         switch (SQLGetInfoShort(SQL_QUOTED_IDENTIFIER_CASE))
  2294.         {
  2295.         case SQL_IC_UPPER:
  2296.             m_strSqlQuotedIdentifierCase = _T("Upper");
  2297.             break;
  2298.         case SQL_IC_LOWER:
  2299.             m_strSqlQuotedIdentifierCase = _T("Lower");
  2300.             break;
  2301.         case SQL_IC_SENSITIVE:
  2302.             m_strSqlQuotedIdentifierCase = _T("Sensitive");
  2303.             break;
  2304.         case SQL_IC_MIXED:
  2305.             m_strSqlQuotedIdentifierCase = _T("Mixed");
  2306.             break;
  2307.         }
  2308.         m_strSqlSearchPatternEscape = SQLGetInfoString(SQL_SEARCH_PATTERN_ESCAPE);
  2309.         m_strSqlSpecialCharacters = SQLGetInfoString(SQL_SPECIAL_CHARACTERS);
  2310.         m_strSqlTableTerm = SQLGetInfoString(SQL_TABLE_TERM);
  2311.         if (IsWindow(m_hWnd))
  2312.         {
  2313.             char    buffer[32000];
  2314.             SWORD    cbData;
  2315.             ::SQLGetInfo(m_pDatabase->m_hdbc,SQL_KEYWORDS,
  2316.                 (PTR)buffer,32000,&cbData);
  2317.             CString    string = buffer;
  2318.             int        n;
  2319.             m_lbDriverKeywords.ResetContent();
  2320.             while ((n = string.Find(',')) != -1)
  2321.             {
  2322.                 m_lbDriverKeywords.AddString(string.Left(n));
  2323.                 string = string.Right(string.GetLength() - n - 1);
  2324.             }
  2325.  
  2326.             UpdateData(FALSE);
  2327.         }
  2328.     }
  2329. }
  2330.  
  2331. BOOL CIdentifiers::OnInitDialog() 
  2332. {
  2333.     CPropertyPage::OnInitDialog();
  2334.     
  2335.     m_lbOdbcKeywords.ResetContent();
  2336.     CString string = SQL_ODBC_KEYWORDS;
  2337.     int        n;
  2338.     while ((n = string.Find(',')) != -1)
  2339.     {
  2340.         m_lbOdbcKeywords.AddString(string.Left(n));
  2341.         string = string.Right(string.GetLength() - n - 1);
  2342.     }
  2343.  
  2344.     char    buffer[32000];
  2345.     SWORD    cbData;
  2346.     ::SQLGetInfo(m_pDatabase->m_hdbc,SQL_KEYWORDS,
  2347.         (PTR)buffer,32000,&cbData);
  2348.     string = buffer;
  2349.     m_lbDriverKeywords.ResetContent();
  2350.     while ((n = string.Find(',')) != -1)
  2351.     {
  2352.         m_lbDriverKeywords.AddString(string.Left(n));
  2353.         string = string.Right(string.GetLength() - n - 1);
  2354.     }
  2355.  
  2356.     UpdateData(FALSE);
  2357.     
  2358.     return TRUE;  // return TRUE unless you set the focus to a control
  2359.                   // EXCEPTION: OCX Property Pages should return FALSE
  2360. }
  2361.  
  2362. /////////////////////////////////////////////////////////////////////////////
  2363. // CLimits property page
  2364.  
  2365. #define    NUM_INTERVALS    9
  2366.  
  2367. IMPLEMENT_DYNCREATE(CLimits, CPropertyPage)
  2368.  
  2369. UWORD CLimits::m_nIntervalMasks[] =
  2370. {
  2371.     SQL_FN_TSI_FRAC_SECOND,
  2372.     SQL_FN_TSI_SECOND,
  2373.     SQL_FN_TSI_MINUTE,
  2374.     SQL_FN_TSI_HOUR,
  2375.     SQL_FN_TSI_DAY,
  2376.     SQL_FN_TSI_WEEK,
  2377.     SQL_FN_TSI_MONTH,
  2378.     SQL_FN_TSI_QUARTER,
  2379.     SQL_FN_TSI_YEAR
  2380. };
  2381.  
  2382. char* CLimits::m_szIntervalNames[] =
  2383. {
  2384.     _T("Second Fraction"),
  2385.     _T("Second"),
  2386.     _T("Minute"),
  2387.     _T("Hour"),
  2388.     _T("Day"),
  2389.     _T("Week"),
  2390.     _T("Month"),
  2391.     _T("Quarter"),
  2392.     _T("Year")
  2393. };
  2394.  
  2395. CLimits::CLimits(CDatabase* pDatabase)
  2396.  : CMyPage(pDatabase,CLimits::IDD)
  2397. {
  2398.     //{{AFX_DATA_INIT(CLimits)
  2399.     m_strSqlMaxBinaryLiteralLen = _T("");
  2400.     m_strSqlMaxCharLiteralLen = _T("");
  2401.     m_strSqlMaxColumnNameLen = _T("");
  2402.     m_strSqlMaxColumnsInGroupBy = _T("");
  2403.     m_strSqlMaxColumnsInIndex = _T("");
  2404.     m_strSqlMaxColumnsInOrderBy = _T("");
  2405.     m_strSqlMaxColumnsInSelect = _T("");
  2406.     m_strSqlMaxColumnsInTable = _T("");
  2407.     m_strSqlMaxCursorNameLen = _T("");
  2408.     m_strSqlMaxIndexSize = _T("");
  2409.     m_strSqlMaxOwnerNameLen = _T("");
  2410.     m_strSqlMaxProcedureNameLen = _T("");
  2411.     m_strSqlMaxQualifierNameLen = _T("");
  2412.     m_strSqlMaxRowSize = _T("");
  2413.     m_strSqlMaxRowSizeIncludesLong = _T("");
  2414.     m_strSqlMaxStatementLen = _T("");
  2415.     m_strSqlMaxTableNameLen = _T("");
  2416.     m_strSqlMaxTablesInSelect = _T("");
  2417.     m_strSqlMaxUserNameLen = _T("");
  2418.     //}}AFX_DATA_INIT
  2419.  
  2420.     OnNewDSN();
  2421. }
  2422.  
  2423. CLimits::~CLimits()
  2424. {
  2425. }
  2426.  
  2427. void CLimits::DumpToFile(CStdioFile& file)
  2428. {
  2429.     if (m_pDatabase->IsOpen())
  2430.     {
  2431.         CString    string;
  2432.         BOOL    b;
  2433.  
  2434.         file.WriteString(_T("Limits\n------\n\n"));
  2435.         string.Format(_T("Max Binary Literal Length - %s\n"),m_strSqlMaxBinaryLiteralLen);
  2436.         file.WriteString(string);
  2437.         string.Format(_T("  Max Char Literal Length - %s\n"),m_strSqlMaxCharLiteralLen);
  2438.         file.WriteString(string);
  2439.         string.Format(_T("   Max Column Name Length - %s\n"),m_strSqlMaxColumnNameLen);
  2440.         file.WriteString(string);
  2441.         string.Format(_T("  Max Columns in GROUP BY - %s\n"),m_strSqlMaxColumnsInGroupBy);
  2442.         file.WriteString(string);
  2443.         string.Format(_T("     Max Columns in Index - %s\n"),m_strSqlMaxColumnsInIndex);
  2444.         file.WriteString(string);
  2445.         string.Format(_T("  Max Columns in ORDER BY - %s\n"),m_strSqlMaxColumnsInOrderBy);
  2446.         file.WriteString(string);
  2447.         string.Format(_T("    Max Columns in SELECT - %s\n"),m_strSqlMaxColumnsInSelect);
  2448.         file.WriteString(string);
  2449.         string.Format(_T("     Max Columns in Table - %s\n"),m_strSqlMaxColumnsInTable);
  2450.         file.WriteString(string);
  2451.         string.Format(_T("   Max Cursor Name Length - %s\n"),m_strSqlMaxCursorNameLen);
  2452.         file.WriteString(string);
  2453.         string.Format(_T("           Max Index Size - %s\n"),m_strSqlMaxIndexSize);
  2454.         file.WriteString(string);
  2455.         string.Format(_T("    Max Owner Name Length - %s\n"),m_strSqlMaxOwnerNameLen);
  2456.         file.WriteString(string);
  2457.         string.Format(_T("Max Procedure Name Length - %s\n"),m_strSqlMaxProcedureNameLen);
  2458.         file.WriteString(string);
  2459.         string.Format(_T("Max Qualifier Name Length - %s\n"),m_strSqlMaxQualifierNameLen);
  2460.         file.WriteString(string);
  2461.         string.Format(_T("             Max Row Size - %s\n"),m_strSqlMaxRowSize);
  2462.         file.WriteString(string);
  2463.         string.Format(_T("Max Rowsize Includes Long - %s\n"),m_strSqlMaxRowSizeIncludesLong);
  2464.         file.WriteString(string);
  2465.         string.Format(_T("     Max Statement Length - %s\n"),m_strSqlMaxStatementLen);
  2466.         file.WriteString(string);
  2467.         string.Format(_T("    Max Table Name Length - %s\n"),m_strSqlMaxTableNameLen);
  2468.         file.WriteString(string);
  2469.         string.Format(_T("     Max Tables In SELECT - %s\n"),m_strSqlMaxTablesInSelect);
  2470.         file.WriteString(string);
  2471.         string.Format(_T("     Max User Name Length - %s\n\n"),m_strSqlMaxUserNameLen);
  2472.         file.WriteString(string);
  2473.  
  2474.         if (!(SQLGetInfoLong(SQL_TIMEDATE_FUNCTIONS) & SQL_FN_TD_TIMESTAMPADD))
  2475.             file.WriteString(_T("Timestamp Add Intervals: <n/a>\n\n"));
  2476.         else
  2477.         {
  2478.             file.WriteString(_T("Timestamp Add Intervals:\n"));
  2479.             UDWORD    fAddIntervals = SQLGetInfoLong(SQL_TIMEDATE_ADD_INTERVALS);
  2480.             b = FALSE;
  2481.             for (int i = 0; i < NUM_INTERVALS; i++)
  2482.             {
  2483.                 if (m_nIntervalMasks[i] & fAddIntervals)
  2484.                 {
  2485.                     if (b)
  2486.                         file.WriteString(_T(","));
  2487.                     file.WriteString(m_szIntervalNames[i]);
  2488.                     b = TRUE;
  2489.                 }
  2490.             }
  2491.             file.WriteString(_T("\n\n"));
  2492.         }
  2493.         if (!(SQLGetInfoLong(SQL_TIMEDATE_FUNCTIONS) & SQL_FN_TD_TIMESTAMPDIFF))
  2494.             file.WriteString(_T("Timestamp Diff Intervals: <n/a>\n\n"));
  2495.         else
  2496.         {
  2497.             file.WriteString(_T("Timestamp Diff Intervals:\n"));
  2498.             UDWORD    fDiffIntervals = SQLGetInfoLong(SQL_TIMEDATE_DIFF_INTERVALS);
  2499.             b = FALSE;
  2500.             for (int i = 0; i < NUM_INTERVALS; i++)
  2501.             {
  2502.                 if (m_nIntervalMasks[i] & fDiffIntervals)
  2503.                 {
  2504.                     if (b)
  2505.                         file.WriteString(_T(","));
  2506.                     file.WriteString(m_szIntervalNames[i]);
  2507.                     b = TRUE;
  2508.                 }
  2509.             }
  2510.             file.WriteString(_T("\n\n"));
  2511.         }
  2512.  
  2513.         file.WriteString(_T("\n"));
  2514.     }
  2515. }
  2516.  
  2517. void CLimits::DoDataExchange(CDataExchange* pDX)
  2518. {
  2519.     CPropertyPage::DoDataExchange(pDX);
  2520.     //{{AFX_DATA_MAP(CLimits)
  2521.     DDX_Control(pDX, IDC_SQL_TIMEDATE_DIFF_INTERVALS, m_lcSqlTimedateDiffIntervals);
  2522.     DDX_Control(pDX, IDC_SQL_TIMEDATE_ADD_INTERVALS, m_lcSqlTimedateAddIntervals);
  2523.     DDX_Text(pDX, IDC_SQL_MAX_BINARY_LITERAL_LEN, m_strSqlMaxBinaryLiteralLen);
  2524.     DDX_Text(pDX, IDC_SQL_MAX_CHAR_LITERAL_LEN, m_strSqlMaxCharLiteralLen);
  2525.     DDX_Text(pDX, IDC_SQL_MAX_COLUMN_NAME_LEN, m_strSqlMaxColumnNameLen);
  2526.     DDX_Text(pDX, IDC_SQL_MAX_COLUMNS_IN_GROUP_BY, m_strSqlMaxColumnsInGroupBy);
  2527.     DDX_Text(pDX, IDC_SQL_MAX_COLUMNS_IN_INDEX, m_strSqlMaxColumnsInIndex);
  2528.     DDX_Text(pDX, IDC_SQL_MAX_COLUMNS_IN_ORDER_BY, m_strSqlMaxColumnsInOrderBy);
  2529.     DDX_Text(pDX, IDC_SQL_MAX_COLUMNS_IN_SELECT, m_strSqlMaxColumnsInSelect);
  2530.     DDX_Text(pDX, IDC_SQL_MAX_COLUMNS_IN_TABLE, m_strSqlMaxColumnsInTable);
  2531.     DDX_Text(pDX, IDC_SQL_MAX_CURS0R_NAME_LEN, m_strSqlMaxCursorNameLen);
  2532.     DDX_Text(pDX, IDC_SQL_MAX_INDEX_SIZE, m_strSqlMaxIndexSize);
  2533.     DDX_Text(pDX, IDC_SQL_MAX_OWNER_NAME_LEN, m_strSqlMaxOwnerNameLen);
  2534.     DDX_Text(pDX, IDC_SQL_MAX_PROCEDURE_NAME_LEN, m_strSqlMaxProcedureNameLen);
  2535.     DDX_Text(pDX, IDC_SQL_MAX_QUALIFIER_NAME_LEN, m_strSqlMaxQualifierNameLen);
  2536.     DDX_Text(pDX, IDC_SQL_MAX_ROW_SIZE, m_strSqlMaxRowSize);
  2537.     DDX_Text(pDX, IDC_SQL_MAX_ROW_SIZE_INCLUDES_LONG, m_strSqlMaxRowSizeIncludesLong);
  2538.     DDX_Text(pDX, IDC_SQL_MAX_STATEMENT_LEN, m_strSqlMaxStatementLen);
  2539.     DDX_Text(pDX, IDC_SQL_MAX_TABLE_NAME_LEN, m_strSqlMaxTableNameLen);
  2540.     DDX_Text(pDX, IDC_SQL_MAX_TABLES_IN_SELECT, m_strSqlMaxTablesInSelect);
  2541.     DDX_Text(pDX, IDC_SQL_MAX_USER_NAME_LEN, m_strSqlMaxUserNameLen);
  2542.     //}}AFX_DATA_MAP
  2543. }
  2544.  
  2545.  
  2546. BEGIN_MESSAGE_MAP(CLimits, CPropertyPage)
  2547.     //{{AFX_MSG_MAP(CLimits)
  2548.     //}}AFX_MSG_MAP
  2549. END_MESSAGE_MAP()
  2550.  
  2551. /////////////////////////////////////////////////////////////////////////////
  2552. // CLimits message handlers
  2553.  
  2554. void CLimits::OnNewDSN()
  2555. {
  2556.     if (m_pDatabase->IsOpen())
  2557.     {
  2558.         ZeroIsNoneLong(m_strSqlMaxBinaryLiteralLen,SQL_MAX_BINARY_LITERAL_LEN);
  2559.         ZeroIsNoneLong(m_strSqlMaxCharLiteralLen,SQL_MAX_CHAR_LITERAL_LEN);
  2560.         ZeroIsNoneShort(m_strSqlMaxColumnNameLen,SQL_MAX_COLUMN_NAME_LEN);
  2561.         ZeroIsNoneShort(m_strSqlMaxColumnsInGroupBy,SQL_MAX_COLUMNS_IN_GROUP_BY);
  2562.         ZeroIsNoneShort(m_strSqlMaxColumnsInIndex,SQL_MAX_COLUMNS_IN_INDEX);
  2563.         ZeroIsNoneShort(m_strSqlMaxColumnsInOrderBy,SQL_MAX_COLUMNS_IN_ORDER_BY);
  2564.         ZeroIsNoneShort(m_strSqlMaxColumnsInSelect,SQL_MAX_COLUMNS_IN_SELECT);
  2565.         ZeroIsNoneShort(m_strSqlMaxColumnsInTable,SQL_MAX_COLUMNS_IN_TABLE);
  2566.         ZeroIsNoneShort(m_strSqlMaxCursorNameLen,SQL_MAX_CURSOR_NAME_LEN);
  2567.         ZeroIsNoneLong(m_strSqlMaxIndexSize,SQL_MAX_INDEX_SIZE);
  2568.         ZeroIsNoneShort(m_strSqlMaxOwnerNameLen,SQL_MAX_OWNER_NAME_LEN);
  2569.         ZeroIsNoneShort(m_strSqlMaxProcedureNameLen,SQL_MAX_PROCEDURE_NAME_LEN);
  2570.         ZeroIsNoneShort(m_strSqlMaxQualifierNameLen,SQL_MAX_QUALIFIER_NAME_LEN);
  2571.         ZeroIsNoneLong(m_strSqlMaxRowSize,SQL_MAX_ROW_SIZE);
  2572.         YIsYes(m_strSqlMaxRowSizeIncludesLong,SQL_MAX_ROW_SIZE_INCLUDES_LONG);
  2573.         ZeroIsNoneLong(m_strSqlMaxStatementLen,SQL_MAX_STATEMENT_LEN);
  2574.         ZeroIsNoneShort(m_strSqlMaxTableNameLen,SQL_MAX_TABLE_NAME_LEN);
  2575.         ZeroIsNoneShort(m_strSqlMaxTablesInSelect,SQL_MAX_TABLES_IN_SELECT);
  2576.         ZeroIsNoneShort(m_strSqlMaxUserNameLen,SQL_MAX_USER_NAME_LEN);
  2577.     
  2578.         if (IsWindow(m_hWnd))
  2579.         {
  2580.             UDWORD    fAddIntervals = SQLGetInfoLong(SQL_TIMEDATE_ADD_INTERVALS);
  2581.             UDWORD    fDiffIntervals = SQLGetInfoLong(SQL_TIMEDATE_DIFF_INTERVALS);
  2582.  
  2583.             m_lcSqlTimedateAddIntervals.DeleteAllItems();
  2584.             if (!(SQLGetInfoLong(SQL_TIMEDATE_FUNCTIONS) & SQL_FN_TD_TIMESTAMPADD))
  2585.                 m_lcSqlTimedateAddIntervals.InsertItem(0,_T("<n/a>"));
  2586.             else
  2587.             {
  2588.                 for (int i = 0; i < NUM_INTERVALS; i++)
  2589.                 {
  2590.                     int    nCheck = 0;
  2591.                     if (m_nIntervalMasks[i] & fAddIntervals)
  2592.                         nCheck = 1;
  2593.                     m_lcSqlTimedateAddIntervals.InsertItem(
  2594.                         i,m_szIntervalNames[i],nCheck);
  2595.                 }
  2596.             }
  2597.  
  2598.             m_lcSqlTimedateDiffIntervals.DeleteAllItems();
  2599.             if (!(SQLGetInfoLong(SQL_TIMEDATE_FUNCTIONS) & SQL_FN_TD_TIMESTAMPDIFF))
  2600.                 m_lcSqlTimedateDiffIntervals.InsertItem(0,_T("<n/a>"));
  2601.             else
  2602.             {
  2603.                 for (int i = 0; i < NUM_INTERVALS; i++)
  2604.                 {
  2605.                     int    nCheck = 0;
  2606.                     if (m_nIntervalMasks[i] & fDiffIntervals)
  2607.                         nCheck = 1;
  2608.                     m_lcSqlTimedateDiffIntervals.InsertItem(
  2609.                         i,m_szIntervalNames[i],nCheck);
  2610.                 }
  2611.             }
  2612.  
  2613.             UpdateData(FALSE);
  2614.         }
  2615.     }
  2616. }
  2617.  
  2618. BOOL CLimits::OnInitDialog() 
  2619. {
  2620.     CPropertyPage::OnInitDialog();
  2621.  
  2622.     m_lcSqlTimedateDiffIntervals.SetImageList(m_pImageList,LVSIL_SMALL);
  2623.     m_lcSqlTimedateAddIntervals.SetImageList(m_pImageList,LVSIL_SMALL);
  2624.  
  2625.     m_lcSqlTimedateDiffIntervals.InsertColumn(0,"",LVCFMT_LEFT,100);
  2626.     m_lcSqlTimedateAddIntervals.InsertColumn(0,"",LVCFMT_LEFT,100);
  2627.  
  2628.     UDWORD    fAddIntervals = SQLGetInfoLong(SQL_TIMEDATE_ADD_INTERVALS);
  2629.     UDWORD    fDiffIntervals = SQLGetInfoLong(SQL_TIMEDATE_DIFF_INTERVALS);
  2630.  
  2631.     m_lcSqlTimedateAddIntervals.DeleteAllItems();
  2632.     if (!(SQLGetInfoLong(SQL_TIMEDATE_FUNCTIONS) & SQL_FN_TD_TIMESTAMPADD))
  2633.         m_lcSqlTimedateAddIntervals.InsertItem(0,_T("<n/a>"));
  2634.     else
  2635.     {
  2636.         for (int i = 0; i < NUM_INTERVALS; i++)
  2637.         {
  2638.             int    nCheck = 0;
  2639.             if (m_nIntervalMasks[i] & fAddIntervals)
  2640.                 nCheck = 1;
  2641.             m_lcSqlTimedateAddIntervals.InsertItem(
  2642.                 i,m_szIntervalNames[i],nCheck);
  2643.         }
  2644.     }
  2645.  
  2646.     m_lcSqlTimedateDiffIntervals.DeleteAllItems();
  2647.     if (!(SQLGetInfoLong(SQL_TIMEDATE_FUNCTIONS) & SQL_FN_TD_TIMESTAMPDIFF))
  2648.         m_lcSqlTimedateDiffIntervals.InsertItem(0,_T("<n/a>"));
  2649.     else
  2650.     {
  2651.         for (int i = 0; i < NUM_INTERVALS; i++)
  2652.         {
  2653.             int    nCheck = 0;
  2654.             if (m_nIntervalMasks[i] & fDiffIntervals)
  2655.                 nCheck = 1;
  2656.             m_lcSqlTimedateDiffIntervals.InsertItem(
  2657.                 i,m_szIntervalNames[i],nCheck);
  2658.         }
  2659.     }
  2660.  
  2661.     UpdateData(FALSE);
  2662.     
  2663.     return TRUE;  // return TRUE unless you set the focus to a control
  2664.                   // EXCEPTION: OCX Property Pages should return FALSE
  2665. }
  2666.  
  2667. /////////////////////////////////////////////////////////////////////////////
  2668. // CMisc1 property page
  2669.  
  2670. IMPLEMENT_DYNCREATE(CMisc1, CPropertyPage)
  2671.  
  2672. CMisc1::CMisc1(CDatabase* pDatabase)
  2673.  : CMyPage(pDatabase,CMisc1::IDD)
  2674. {
  2675.     //{{AFX_DATA_INIT(CMisc1)
  2676.     m_strSqlTxnCapable = _T("");
  2677.     m_strSqlCursorCommitBehavior = _T("");
  2678.     m_strSqlCursorRollbackBehavior = _T("");
  2679.     m_bSqlTxnReadCommitted = FALSE;
  2680.     m_bSqlTxnReadUncommitted = FALSE;
  2681.     m_bSqlTxnRepeatableRead = FALSE;
  2682.     m_bSqlTxnSerializable = FALSE;
  2683.     m_bSqlTxnVersioning = FALSE;
  2684.     m_strSqlDefaultTxnIsolation = _T("");
  2685.     m_strSqlMultipleActiveTxn = _T("");
  2686.     m_bSqlBpClose = FALSE;
  2687.     m_bSqlBpDelete = FALSE;
  2688.     m_bSqlBpDrop = FALSE;
  2689.     m_bSqlBpOtherHstmt = FALSE;
  2690.     m_bSqlBpScroll = FALSE;
  2691.     m_bSqlBpTransaction = FALSE;
  2692.     m_bSqlBpUpdate = FALSE;
  2693.     m_bSqlLckExclusive = FALSE;
  2694.     m_bSqlLckNoChange = FALSE;
  2695.     m_bSqlLckUnlock = FALSE;
  2696.     m_bSqlSsAdditions = FALSE;
  2697.     m_bSqlSsDeletions = FALSE;
  2698.     m_bSqlSsUpdates = FALSE;
  2699.     //}}AFX_DATA_INIT
  2700.  
  2701.     OnNewDSN();
  2702. }
  2703.  
  2704. CMisc1::~CMisc1()
  2705. {
  2706. }
  2707.  
  2708. void CMisc1::DumpToFile(CStdioFile& file)
  2709. {
  2710.     if (m_pDatabase->IsOpen())
  2711.     {
  2712.         CString    string;
  2713.         CString    workString;
  2714.         BOOL    b;
  2715.  
  2716.         file.WriteString(_T("Miscellaneous\n-------------\n\n"));
  2717.  
  2718.         string.Format(_T(" Transaction Capabilities - %s\n"),m_strSqlTxnCapable);
  2719.         file.WriteString(string);
  2720.         string.Format(_T("   Cursor Commit Behavior - %s\n"),m_strSqlCursorCommitBehavior);
  2721.         file.WriteString(string);
  2722.         string.Format(_T(" Cursor Rollback Behavior - %s\n"),m_strSqlCursorRollbackBehavior);
  2723.         file.WriteString(string);
  2724.         file.WriteString(_T("  Trans. Isolation Levels - "));
  2725.         b = FALSE;
  2726.         if (m_bSqlTxnReadCommitted)
  2727.         {
  2728.             file.WriteString(_T("Read Commit"));
  2729.             b = TRUE;
  2730.         }
  2731.         if (m_bSqlTxnReadUncommitted)
  2732.         {
  2733.             if (b)
  2734.                 file.WriteString(_T(","));
  2735.             file.WriteString(_T("Read Uncommit"));
  2736.             b = TRUE;
  2737.         }
  2738.         if (m_bSqlTxnRepeatableRead)
  2739.         {
  2740.             if (b)
  2741.                 file.WriteString(_T(","));
  2742.             file.WriteString(_T("Repeat Read"));
  2743.             b = TRUE;
  2744.         }
  2745.         if (m_bSqlTxnSerializable)
  2746.         {
  2747.             if (b)
  2748.                 file.WriteString(_T(","));
  2749.             file.WriteString(_T("Serializable"));
  2750.             b = TRUE;
  2751.         }
  2752.         if (m_bSqlTxnVersioning)
  2753.         {
  2754.             if (b)
  2755.                 file.WriteString(_T(","));
  2756.             file.WriteString(_T("Versioning"));
  2757.             b = TRUE;
  2758.         }
  2759.         if (!b)
  2760.             file.WriteString(_T("<none>"));
  2761.         file.WriteString(_T("\n"));
  2762.         string.Format(_T(" Default Trans. Isolation - %s\n"),m_strSqlDefaultTxnIsolation);
  2763.         file.WriteString(string);
  2764.         string.Format(_T("   Multiple Active Trans. - %s\n"),m_strSqlMultipleActiveTxn);
  2765.         file.WriteString(string);
  2766.         file.WriteString(_T("     Bookmark Persistance - "));
  2767.         b = FALSE;
  2768.         if (m_bSqlBpClose)
  2769.         {
  2770.             file.WriteString(_T("Close"));
  2771.             b = TRUE;
  2772.         }
  2773.         if (m_bSqlBpDelete)
  2774.         {
  2775.             if (b)
  2776.                 file.WriteString(_T(","));
  2777.             file.WriteString(_T("Delete"));
  2778.             b = TRUE;
  2779.         }
  2780.         if (m_bSqlBpDrop)
  2781.         {
  2782.             if (b)
  2783.                 file.WriteString(_T(","));
  2784.             file.WriteString(_T("Drop"));
  2785.             b = TRUE;
  2786.         }
  2787.         if (m_bSqlBpOtherHstmt)
  2788.         {
  2789.             if (b)
  2790.                 file.WriteString(_T(","));
  2791.             file.WriteString(_T("Other HSTMT"));
  2792.             b = TRUE;
  2793.         }
  2794.         if (m_bSqlBpScroll)
  2795.         {
  2796.             if (b)
  2797.                 file.WriteString(_T(","));
  2798.             file.WriteString(_T("Scroll"));
  2799.             b = TRUE;
  2800.         }
  2801.         if (m_bSqlBpTransaction)
  2802.         {
  2803.             if (b)
  2804.                 file.WriteString(_T(","));
  2805.             file.WriteString(_T("Transaction"));
  2806.             b = TRUE;
  2807.         }
  2808.         if (m_bSqlBpUpdate)
  2809.         {
  2810.             if (b)
  2811.                 file.WriteString(_T(","));
  2812.             file.WriteString(_T("Update"));
  2813.             b = TRUE;
  2814.         }
  2815.         if (!b)
  2816.             file.WriteString(_T("<none>"));
  2817.         file.WriteString(_T("\n"));
  2818.  
  2819.         file.WriteString(_T("               Lock Types - "));
  2820.         b = FALSE;
  2821.         if (m_bSqlLckExclusive)
  2822.         {
  2823.             file.WriteString(_T("Exclusive"));
  2824.             b = TRUE;
  2825.         }
  2826.         if (m_bSqlLckNoChange)
  2827.         {
  2828.             if (b)
  2829.                 file.WriteString(_T(","));
  2830.             file.WriteString(_T("No Change"));
  2831.             b = TRUE;
  2832.         }
  2833.         if (m_bSqlLckUnlock)
  2834.         {
  2835.             if (b)
  2836.                 file.WriteString(_T(","));
  2837.             file.WriteString(_T("Unlock"));
  2838.             b = TRUE;
  2839.         }
  2840.         if (!b)
  2841.             file.WriteString(_T("<none>"));
  2842.         file.WriteString(_T("\n"));
  2843.  
  2844.         file.WriteString(_T("       Static Sensitivity - "));
  2845.         b = FALSE;
  2846.         if (m_bSqlSsAdditions)
  2847.         {
  2848.             file.WriteString(_T("Additions"));
  2849.             b = TRUE;
  2850.         }
  2851.         if (m_bSqlSsDeletions)
  2852.         {
  2853.             if (b)
  2854.                 file.WriteString(_T(","));
  2855.             file.WriteString(_T("Deletions"));
  2856.             b = TRUE;
  2857.         }
  2858.         if (m_bSqlSsUpdates)
  2859.         {
  2860.             if (b)
  2861.                 file.WriteString(_T(","));
  2862.             file.WriteString(_T("Updates"));
  2863.             b = TRUE;
  2864.         }
  2865.         if (!b)
  2866.             file.WriteString(_T("<none>"));
  2867.         file.WriteString(_T("\n\n"));
  2868.     }
  2869. }
  2870.  
  2871. void CMisc1::DoDataExchange(CDataExchange* pDX)
  2872. {
  2873.     CPropertyPage::DoDataExchange(pDX);
  2874.     //{{AFX_DATA_MAP(CMisc1)
  2875.     DDX_Text(pDX, IDC_SQL_TXN_CAPABLE, m_strSqlTxnCapable);
  2876.     DDX_Text(pDX, IDC_SQL_CURSOR_COMMIT_BEHAVIOR, m_strSqlCursorCommitBehavior);
  2877.     DDX_Text(pDX, IDC_SQL_CURSOR_ROLLBACK_BEHAVIOR, m_strSqlCursorRollbackBehavior);
  2878.     DDX_Check(pDX, IDC_SQL_TXN_READ_COMMITTED, m_bSqlTxnReadCommitted);
  2879.     DDX_Check(pDX, IDC_SQL_TXN_READ_UNCOMMITTED, m_bSqlTxnReadUncommitted);
  2880.     DDX_Check(pDX, IDC_SQL_TXN_REPEATABLE_READ, m_bSqlTxnRepeatableRead);
  2881.     DDX_Check(pDX, IDC_SQL_TXN_SERIALIZABLE, m_bSqlTxnSerializable);
  2882.     DDX_Check(pDX, IDC_SQL_TXN_VERSIONING, m_bSqlTxnVersioning);
  2883.     DDX_Text(pDX, IDC_SQL_DEFAULT_TXN_ISOLATION, m_strSqlDefaultTxnIsolation);
  2884.     DDX_Text(pDX, IDC_SQL_MULTIPLE_ACTIVE_TXN, m_strSqlMultipleActiveTxn);
  2885.     DDX_Check(pDX, IDC_SQL_BP_CLOSE, m_bSqlBpClose);
  2886.     DDX_Check(pDX, IDC_SQL_BP_DELETE, m_bSqlBpDelete);
  2887.     DDX_Check(pDX, IDC_SQL_BP_DROP, m_bSqlBpDrop);
  2888.     DDX_Check(pDX, IDC_SQL_BP_OTHER_HSTMT, m_bSqlBpOtherHstmt);
  2889.     DDX_Check(pDX, IDC_SQL_BP_SCROLL, m_bSqlBpScroll);
  2890.     DDX_Check(pDX, IDC_SQL_BP_TRANSACTION, m_bSqlBpTransaction);
  2891.     DDX_Check(pDX, IDC_SQL_BP_UPDATE, m_bSqlBpUpdate);
  2892.     DDX_Check(pDX, IDC_SQL_LCK_EXCLUSIVE, m_bSqlLckExclusive);
  2893.     DDX_Check(pDX, IDC_SQL_LCK_NO_CHANGE, m_bSqlLckNoChange);
  2894.     DDX_Check(pDX, IDC_SQL_LCK_UNLOCK, m_bSqlLckUnlock);
  2895.     DDX_Check(pDX, IDC_SQL_SS_ADDITIONS, m_bSqlSsAdditions);
  2896.     DDX_Check(pDX, IDC_SQL_SS_DELETIONS, m_bSqlSsDeletions);
  2897.     DDX_Check(pDX, IDC_SQL_SS_UPDATES, m_bSqlSsUpdates);
  2898.     //}}AFX_DATA_MAP
  2899. }
  2900.  
  2901. BEGIN_MESSAGE_MAP(CMisc1, CPropertyPage)
  2902.     //{{AFX_MSG_MAP(CMisc1)
  2903.     //}}AFX_MSG_MAP
  2904. END_MESSAGE_MAP()
  2905.  
  2906. /////////////////////////////////////////////////////////////////////////////
  2907. // CMisc1 message handlers
  2908.  
  2909. void CMisc1::OnNewDSN()
  2910. {
  2911.     if (m_pDatabase->IsOpen())
  2912.     {
  2913.         SDWORD    longValue;
  2914.  
  2915.         switch (SQLGetInfoShort(SQL_TXN_CAPABLE))
  2916.         {
  2917.         case SQL_TC_NONE:
  2918.             m_strSqlTxnCapable = _T("None");
  2919.             m_strSqlCursorCommitBehavior = _T("<n/a>");
  2920.             m_strSqlCursorRollbackBehavior = _T("<n/a>");
  2921.             m_bSqlTxnReadUncommitted = FALSE;
  2922.             m_bSqlTxnReadCommitted = FALSE;
  2923.             m_bSqlTxnRepeatableRead = FALSE;
  2924.             m_bSqlTxnSerializable = FALSE;
  2925.             m_bSqlTxnVersioning = FALSE;
  2926.             m_strSqlDefaultTxnIsolation = _T("<n/a>");
  2927.             m_strSqlMultipleActiveTxn = _T("<n/a>");
  2928.             UpdateData(FALSE);
  2929.             return;
  2930.         case SQL_TC_DML:
  2931.             m_strSqlTxnCapable = _T("DDL statements cause an error");
  2932.             break;
  2933.         case SQL_TC_DDL_COMMIT:
  2934.             m_strSqlTxnCapable = _T("DDL statements cause a commit");
  2935.             break;
  2936.         case SQL_TC_DDL_IGNORE:
  2937.             m_strSqlTxnCapable = _T("DDL statements are ignored");
  2938.             break;
  2939.         case SQL_TC_ALL:
  2940.             m_strSqlTxnCapable = _T("DDL and DML statements supported");
  2941.             break;
  2942.         }
  2943.  
  2944.         switch (SQLGetInfoShort(SQL_CURSOR_COMMIT_BEHAVIOR))
  2945.         {
  2946.         case SQL_CB_DELETE:
  2947.             m_strSqlCursorCommitBehavior = _T("Close Cursors, Delete Statements");
  2948.             break;
  2949.         case SQL_CB_CLOSE:
  2950.             m_strSqlCursorCommitBehavior = _T("Close Cursors");
  2951.             break;
  2952.         case SQL_CB_PRESERVE:
  2953.             m_strSqlCursorCommitBehavior = _T("Preserve Cursors");
  2954.             break;
  2955.         }
  2956.  
  2957.         switch (SQLGetInfoShort(SQL_CURSOR_ROLLBACK_BEHAVIOR))
  2958.         {
  2959.         case SQL_CB_DELETE:
  2960.             m_strSqlCursorRollbackBehavior = _T("Close Cursors, Delete Statements");
  2961.             break;
  2962.         case SQL_CB_CLOSE:
  2963.             m_strSqlCursorRollbackBehavior = _T("Close Cursors");
  2964.             break;
  2965.         case SQL_CB_PRESERVE:
  2966.             m_strSqlCursorRollbackBehavior = _T("Preserve Cursors");
  2967.             break;
  2968.         }
  2969.  
  2970.         longValue = SQLGetInfoLong(SQL_TXN_ISOLATION_OPTION);
  2971.         if (longValue & SQL_TXN_READ_UNCOMMITTED)
  2972.             m_bSqlTxnReadUncommitted = TRUE;
  2973.         else
  2974.             m_bSqlTxnReadUncommitted = FALSE;
  2975.         if (longValue & SQL_TXN_READ_COMMITTED)
  2976.             m_bSqlTxnReadCommitted = TRUE;
  2977.         else
  2978.             m_bSqlTxnReadCommitted = FALSE;
  2979.         if (longValue & SQL_TXN_REPEATABLE_READ)
  2980.             m_bSqlTxnRepeatableRead = TRUE;
  2981.         else
  2982.             m_bSqlTxnRepeatableRead = FALSE;
  2983.         if (longValue & SQL_TXN_SERIALIZABLE)
  2984.             m_bSqlTxnSerializable = TRUE;
  2985.         else
  2986.             m_bSqlTxnSerializable = FALSE;
  2987.         if (longValue & SQL_TXN_VERSIONING)
  2988.             m_bSqlTxnVersioning = TRUE;
  2989.         else
  2990.             m_bSqlTxnVersioning = FALSE;
  2991.  
  2992.         switch (SQLGetInfoLong(SQL_DEFAULT_TXN_ISOLATION))
  2993.         {
  2994.         case SQL_TXN_READ_UNCOMMITTED:
  2995.             m_strSqlDefaultTxnIsolation = _T("Read Uncommitted");
  2996.             break;
  2997.         case SQL_TXN_READ_COMMITTED:
  2998.             m_strSqlDefaultTxnIsolation = _T("Read Committed");
  2999.             break;
  3000.         case SQL_TXN_REPEATABLE_READ:
  3001.             m_strSqlDefaultTxnIsolation = _T("Repeatable Read");
  3002.             break;
  3003.         case SQL_TXN_SERIALIZABLE:
  3004.             m_strSqlDefaultTxnIsolation = _T("Serializable");
  3005.             break;
  3006.         case SQL_TXN_VERSIONING:
  3007.             m_strSqlDefaultTxnIsolation = _T("Versioning");
  3008.             break;
  3009.         }
  3010.         YIsSupported(m_strSqlMultipleActiveTxn,SQL_MULTIPLE_ACTIVE_TXN);
  3011.         longValue = SQLGetInfoLong(SQL_BOOKMARK_PERSISTENCE);
  3012.         if (longValue & SQL_BP_CLOSE)
  3013.             m_bSqlBpClose = TRUE;
  3014.         else
  3015.             m_bSqlBpClose = FALSE;
  3016.         if (longValue & SQL_BP_DELETE)
  3017.             m_bSqlBpDelete = TRUE;
  3018.         else
  3019.             m_bSqlBpDelete = FALSE;
  3020.         if (longValue & SQL_BP_DROP)
  3021.             m_bSqlBpDrop = TRUE;
  3022.         else
  3023.             m_bSqlBpDrop = FALSE;
  3024.         if (longValue & SQL_BP_SCROLL)
  3025.             m_bSqlBpScroll = TRUE;
  3026.         else
  3027.             m_bSqlBpScroll = FALSE;
  3028.         if (longValue & SQL_BP_TRANSACTION)
  3029.             m_bSqlBpTransaction = TRUE;
  3030.         else
  3031.             m_bSqlBpTransaction = FALSE;
  3032.         if (longValue & SQL_BP_UPDATE)
  3033.             m_bSqlBpUpdate = TRUE;
  3034.         else
  3035.             m_bSqlBpUpdate = FALSE;
  3036.         if (longValue & SQL_BP_OTHER_HSTMT)
  3037.             m_bSqlBpOtherHstmt = TRUE;
  3038.         else
  3039.             m_bSqlBpOtherHstmt = FALSE;
  3040.  
  3041.         longValue = SQLGetInfoLong(SQL_LOCK_TYPES);
  3042.         if (longValue & SQL_LCK_NO_CHANGE)
  3043.             m_bSqlLckNoChange = TRUE;
  3044.         else
  3045.             m_bSqlLckNoChange = FALSE;
  3046.         if (longValue & SQL_LCK_EXCLUSIVE)
  3047.             m_bSqlLckExclusive = TRUE;
  3048.         else
  3049.             m_bSqlLckExclusive = FALSE;
  3050.         if (longValue & SQL_LCK_UNLOCK)
  3051.             m_bSqlLckUnlock = TRUE;
  3052.         else
  3053.             m_bSqlLckUnlock = FALSE;
  3054.  
  3055.         longValue = SQLGetInfoLong(SQL_STATIC_SENSITIVITY);
  3056.         if (longValue & SQL_SS_ADDITIONS)
  3057.             m_bSqlSsAdditions = TRUE;
  3058.         else
  3059.             m_bSqlSsAdditions = FALSE;
  3060.         if (longValue & SQL_SS_DELETIONS)
  3061.             m_bSqlSsDeletions = TRUE;
  3062.         else
  3063.             m_bSqlSsDeletions = FALSE;
  3064.         if (longValue & SQL_SS_UPDATES)
  3065.             m_bSqlSsUpdates = TRUE;
  3066.         else
  3067.             m_bSqlSsUpdates = FALSE;
  3068.  
  3069.         if (IsWindow(m_hWnd))
  3070.             UpdateData(FALSE);
  3071.     }
  3072. }
  3073.  
  3074. BOOL CMisc1::OnInitDialog() 
  3075. {
  3076.     CPropertyPage::OnInitDialog();
  3077.     
  3078.     UpdateData(FALSE);
  3079.     
  3080.     return TRUE;  // return TRUE unless you set the focus to a control
  3081.                   // EXCEPTION: OCX Property Pages should return FALSE
  3082. }
  3083.  
  3084. /////////////////////////////////////////////////////////////////////////////
  3085. // CMisc2 property page
  3086.  
  3087. IMPLEMENT_DYNCREATE(CMisc2, CPropertyPage)
  3088.  
  3089. CMisc2::CMisc2(CDatabase* pDatabase)
  3090.     : CMyPage(pDatabase,CMisc2::IDD)
  3091.  {
  3092.     //{{AFX_DATA_INIT(CMisc2)
  3093.     m_bSqlOuDmlStatements = FALSE;
  3094.     m_bSqlOuIndexDefinition = FALSE;
  3095.     m_bSqlOuPrivilegeDefinition = FALSE;
  3096.     m_bSqlOuProcedureInvocation = FALSE;
  3097.     m_bSqlOuTableDefinition = FALSE;
  3098.     m_bSqlQuDmlStatements = FALSE;
  3099.     m_bSqlQuIndexDefinition = FALSE;
  3100.     m_bSqlQuPrivilegeDefinition = FALSE;
  3101.     m_bSqlQuProcedureInvocation = FALSE;
  3102.     m_bSqlQuTableDefinition = FALSE;
  3103.     m_bSqlSoDynamic = FALSE;
  3104.     m_bSqlSoForwardOnly = FALSE;
  3105.     m_bSqlSoKeysetDriven = FALSE;
  3106.     m_bSqlSoMixed = FALSE;
  3107.     m_bSqlSoStatic = FALSE;
  3108.     m_bSqlSccoLock = FALSE;
  3109.     m_bSqlSccoOptRowver = FALSE;
  3110.     m_bSqlSccoOptValues = FALSE;
  3111.     m_bSqlSccoReadOnly = FALSE;
  3112.     m_bSqlPosAdd = FALSE;
  3113.     m_bSqlPosDelete = FALSE;
  3114.     m_bSqlPosPosition = FALSE;
  3115.     m_bSqlPosRefresh = FALSE;
  3116.     m_bSqlPosUpdate = FALSE;
  3117.     m_bSqlFdFetchAbsolute = FALSE;
  3118.     m_bSqlFdFetchBookmark = FALSE;
  3119.     m_bSqlFdFetchFirst = FALSE;
  3120.     m_bSqlFdFetchLast = FALSE;
  3121.     m_bSqlFdFetchNext = FALSE;
  3122.     m_bSqlFdFetchPrior = FALSE;
  3123.     m_bSqlFdFetchRelative = FALSE;
  3124.     m_bSqlFdFetchResume = FALSE;
  3125.     m_bSqlGdAnyColumn = FALSE;
  3126.     m_bSqlGdAnyOrder = FALSE;
  3127.     m_bSqlGdBlock = FALSE;
  3128.     m_bSqlGdBound = FALSE;
  3129.     m_strSqlConcatNullBehavior = _T("");
  3130.     m_strSqlNeedLongDataLen = _T("");
  3131.     m_strSqlNonNullableColumns = _T("");
  3132.     m_strSqlNullCollation = _T("");
  3133.     m_strSqlProcedures = _T("");
  3134.     m_strSqlRowUpdates = _T("");
  3135.     //}}AFX_DATA_INIT
  3136.  
  3137.     OnNewDSN();
  3138. }
  3139.  
  3140. CMisc2::~CMisc2()
  3141. {
  3142. }
  3143.  
  3144. void CMisc2::DumpToFile(CStdioFile& file)
  3145. {
  3146.     if (m_pDatabase->IsOpen())
  3147.     {
  3148.         CString    string;
  3149.         BOOL    b;
  3150.  
  3151.         string.Format(_T("    Need Long Data Length - %s\n"),m_strSqlNeedLongDataLen);
  3152.         file.WriteString(string);
  3153.         string.Format(_T("     Non-Nullable Columns - %s\n"),m_strSqlNonNullableColumns);
  3154.         file.WriteString(string);
  3155.         string.Format(_T("       Null Concatenation - %s\n"),m_strSqlConcatNullBehavior);
  3156.         file.WriteString(string);
  3157.         string.Format(_T("           Null Collation - %s\n"),m_strSqlNullCollation);
  3158.         file.WriteString(string);
  3159.         string.Format(_T("               Procedures - %s\n"),m_strSqlProcedures);
  3160.         file.WriteString(string);
  3161.         string.Format(_T("              Row Updates - %s\n"),m_strSqlRowUpdates);
  3162.         file.WriteString(string);
  3163.  
  3164.         file.WriteString(_T("          Fetch Direction - "));
  3165.         b = FALSE;
  3166.         if (m_bSqlFdFetchAbsolute)
  3167.         {
  3168.             file.WriteString(_T("Absolute"));
  3169.             b = TRUE;
  3170.         }
  3171.         if (m_bSqlFdFetchBookmark)
  3172.         {
  3173.             if (b)
  3174.                 file.WriteString(_T(","));
  3175.             file.WriteString(_T("Bookmark"));
  3176.             b = TRUE;
  3177.         }
  3178.         if (m_bSqlFdFetchFirst)
  3179.         {
  3180.             if (b)
  3181.                 file.WriteString(_T(","));
  3182.             file.WriteString(_T("First"));
  3183.             b = TRUE;
  3184.         }
  3185.         if (m_bSqlFdFetchLast)
  3186.         {
  3187.             if (b)
  3188.                 file.WriteString(_T(","));
  3189.             file.WriteString(_T("Last"));
  3190.             b = TRUE;
  3191.         }
  3192.         if (m_bSqlFdFetchNext)
  3193.         {
  3194.             if (b)
  3195.                 file.WriteString(_T(","));
  3196.             file.WriteString(_T("Next"));
  3197.             b = TRUE;
  3198.         }
  3199.         if (m_bSqlFdFetchPrior)
  3200.         {
  3201.             if (b)
  3202.                 file.WriteString(_T(","));
  3203.             file.WriteString(_T("Prior"));
  3204.             b = TRUE;
  3205.         }
  3206.         if (m_bSqlFdFetchRelative)
  3207.         {
  3208.             if (b)
  3209.                 file.WriteString(_T(","));
  3210.             file.WriteString(_T("Relative"));
  3211.             b = TRUE;
  3212.         }
  3213.         if (m_bSqlFdFetchResume)
  3214.         {
  3215.             if (b)
  3216.                 file.WriteString(_T(","));
  3217.             file.WriteString(_T("Resume"));
  3218.             b = TRUE;
  3219.         }
  3220.         if (!b)
  3221.             file.WriteString(_T("<none>"));
  3222.         file.WriteString(_T("\n"));
  3223.  
  3224.         file.WriteString(_T("      Get Data Extensions - "));
  3225.         b = FALSE;
  3226.         if (m_bSqlGdAnyColumn)
  3227.         {
  3228.             file.WriteString(_T("Any Column"));
  3229.             b = TRUE;
  3230.         }
  3231.         if (m_bSqlGdAnyOrder)
  3232.         {
  3233.             if (b)
  3234.                 file.WriteString(_T(","));
  3235.             file.WriteString(_T("Any Order"));
  3236.             b = TRUE;
  3237.         }
  3238.         if (m_bSqlGdBlock)
  3239.         {
  3240.             if (b)
  3241.                 file.WriteString(_T(","));
  3242.             file.WriteString(_T("Block"));
  3243.             b = TRUE;
  3244.         }
  3245.         if (m_bSqlGdBound)
  3246.         {
  3247.             if (b)
  3248.                 file.WriteString(_T(","));
  3249.             file.WriteString(_T("Bound"));
  3250.             b = TRUE;
  3251.         }
  3252.         if (!b)
  3253.             file.WriteString(_T("<none>"));
  3254.         file.WriteString(_T("\n"));
  3255.  
  3256.         file.WriteString(_T("    Positioned Operations - "));
  3257.         b = FALSE;
  3258.         if (m_bSqlPosAdd)
  3259.         {
  3260.             file.WriteString(_T("Add"));
  3261.             b = TRUE;
  3262.         }
  3263.         if (m_bSqlPosDelete)
  3264.         {
  3265.             if (b)
  3266.                 file.WriteString(_T(","));
  3267.             file.WriteString(_T("Delete"));
  3268.             b = TRUE;
  3269.         }
  3270.         if (m_bSqlPosPosition)
  3271.         {
  3272.             if (b)
  3273.                 file.WriteString(_T(","));
  3274.             file.WriteString(_T("Position"));
  3275.             b = TRUE;
  3276.         }
  3277.         if (m_bSqlPosRefresh)
  3278.         {
  3279.             if (b)
  3280.                 file.WriteString(_T(","));
  3281.             file.WriteString(_T("Refresh"));
  3282.             b = TRUE;
  3283.         }
  3284.         if (m_bSqlPosUpdate)
  3285.         {
  3286.             if (b)
  3287.                 file.WriteString(_T(","));
  3288.             file.WriteString(_T("Update"));
  3289.             b = TRUE;
  3290.         }
  3291.         if (!b)
  3292.             file.WriteString(_T("<none>"));
  3293.         file.WriteString(_T("\n"));
  3294.  
  3295.         file.WriteString(_T("       Scroll Concurrency - "));
  3296.         b = FALSE;
  3297.         if (m_bSqlSccoLock)
  3298.         {
  3299.             file.WriteString(_T("Lock"));
  3300.             b = TRUE;
  3301.         }
  3302.         if (m_bSqlSccoOptRowver)
  3303.         {
  3304.             if (b)
  3305.                 file.WriteString(_T(","));
  3306.             file.WriteString(_T("Opt/RowVer"));
  3307.             b = TRUE;
  3308.         }
  3309.         if (m_bSqlSccoOptValues)
  3310.         {
  3311.             if (b)
  3312.                 file.WriteString(_T(","));
  3313.             file.WriteString(_T("Opt/Values"));
  3314.             b = TRUE;
  3315.         }
  3316.         if (m_bSqlSccoReadOnly)
  3317.         {
  3318.             if (b)
  3319.                 file.WriteString(_T(","));
  3320.             file.WriteString(_T("Read Only"));
  3321.             b = TRUE;
  3322.         }
  3323.         if (!b)
  3324.             file.WriteString(_T("<none>"));
  3325.         file.WriteString(_T("\n"));
  3326.  
  3327.         file.WriteString(_T("           Scroll Options - "));
  3328.         b = FALSE;
  3329.         if (m_bSqlSoDynamic)
  3330.         {
  3331.             file.WriteString(_T("Dynamic"));
  3332.             b = TRUE;
  3333.         }
  3334.         if (m_bSqlSoForwardOnly)
  3335.         {
  3336.             if (b)
  3337.                 file.WriteString(_T(","));
  3338.             file.WriteString(_T("Forward Only"));
  3339.             b = TRUE;
  3340.         }
  3341.         if (m_bSqlSoKeysetDriven)
  3342.         {
  3343.             if (b)
  3344.                 file.WriteString(_T(","));
  3345.             file.WriteString(_T("Keyset Driven"));
  3346.             b = TRUE;
  3347.         }
  3348.         if (m_bSqlSoMixed)
  3349.         {
  3350.             if (b)
  3351.                 file.WriteString(_T(","));
  3352.             file.WriteString(_T("Mixed"));
  3353.             b = TRUE;
  3354.         }
  3355.         if (m_bSqlSoStatic)
  3356.         {
  3357.             if (b)
  3358.                 file.WriteString(_T(","));
  3359.             file.WriteString(_T("Static"));
  3360.             b = TRUE;
  3361.         }
  3362.         if (!b)
  3363.             file.WriteString(_T("<none>"));
  3364.         file.WriteString(_T("\n"));
  3365.  
  3366.         file.WriteString(_T("              Owner Usage - "));
  3367.         b = FALSE;
  3368.         if (m_bSqlOuDmlStatements)
  3369.         {
  3370.             file.WriteString(_T("DML Stmt"));
  3371.             b = TRUE;
  3372.         }
  3373.         if (m_bSqlOuIndexDefinition)
  3374.         {
  3375.             if (b)
  3376.                 file.WriteString(_T(","));
  3377.             file.WriteString(_T("Index Def"));
  3378.             b = TRUE;
  3379.         }
  3380.         if (m_bSqlOuPrivilegeDefinition)
  3381.         {
  3382.             if (b)
  3383.                 file.WriteString(_T(","));
  3384.             file.WriteString(_T("Priv Def"));
  3385.             b = TRUE;
  3386.         }
  3387.         if (m_bSqlOuProcedureInvocation)
  3388.         {
  3389.             if (b)
  3390.                 file.WriteString(_T(","));
  3391.             file.WriteString(_T("Proc Invoke"));
  3392.             b = TRUE;
  3393.         }
  3394.         if (m_bSqlOuTableDefinition)
  3395.         {
  3396.             if (b)
  3397.                 file.WriteString(_T(","));
  3398.             file.WriteString(_T("Table Def"));
  3399.             b = TRUE;
  3400.         }
  3401.         if (!b)
  3402.             file.WriteString(_T("<none>"));
  3403.         file.WriteString(_T("\n"));
  3404.  
  3405.         file.WriteString(_T("          Qualifier Usage - "));
  3406.         b = FALSE;
  3407.         if (m_bSqlQuDmlStatements)
  3408.         {
  3409.             file.WriteString(_T("DML Stmt"));
  3410.             b = TRUE;
  3411.         }
  3412.         if (m_bSqlQuIndexDefinition)
  3413.         {
  3414.             if (b)
  3415.                 file.WriteString(_T(","));
  3416.             file.WriteString(_T("Index Def"));
  3417.             b = TRUE;
  3418.         }
  3419.         if (m_bSqlQuPrivilegeDefinition)
  3420.         {
  3421.             if (b)
  3422.                 file.WriteString(_T(","));
  3423.             file.WriteString(_T("Priv Def"));
  3424.             b = TRUE;
  3425.         }
  3426.         if (m_bSqlQuProcedureInvocation)
  3427.         {
  3428.             if (b)
  3429.                 file.WriteString(_T(","));
  3430.             file.WriteString(_T("Proc Invoke"));
  3431.             b = TRUE;
  3432.         }
  3433.         if (m_bSqlQuTableDefinition)
  3434.         {
  3435.             if (b)
  3436.                 file.WriteString(_T(","));
  3437.             file.WriteString(_T("Table Def"));
  3438.             b = TRUE;
  3439.         }
  3440.         if (!b)
  3441.             file.WriteString(_T("<none>"));
  3442.         file.WriteString(_T("\n"));
  3443.  
  3444.  
  3445.  
  3446.     }
  3447. }
  3448.  
  3449. void CMisc2::DoDataExchange(CDataExchange* pDX)
  3450. {
  3451.     CPropertyPage::DoDataExchange(pDX);
  3452.     //{{AFX_DATA_MAP(CMisc2)
  3453.     DDX_Check(pDX, IDC_SQL_OU_DML_STATEMENTS, m_bSqlOuDmlStatements);
  3454.     DDX_Check(pDX, IDC_SQL_OU_INDEX_DEFINITION, m_bSqlOuIndexDefinition);
  3455.     DDX_Check(pDX, IDC_SQL_OU_PRIVILEGE_DEFINITION, m_bSqlOuPrivilegeDefinition);
  3456.     DDX_Check(pDX, IDC_SQL_OU_PROCEDURE_INVOCATION, m_bSqlOuProcedureInvocation);
  3457.     DDX_Check(pDX, IDC_SQL_OU_TABLE_DEFINITION, m_bSqlOuTableDefinition);
  3458.     DDX_Check(pDX, IDC_SQL_QU_DML_STATEMENTS, m_bSqlQuDmlStatements);
  3459.     DDX_Check(pDX, IDC_SQL_QU_INDEX_DEFINITION, m_bSqlQuIndexDefinition);
  3460.     DDX_Check(pDX, IDC_SQL_QU_PRIVILEGE_DEFINITION, m_bSqlQuPrivilegeDefinition);
  3461.     DDX_Check(pDX, IDC_SQL_QU_PROCEDURE_INVOCATION, m_bSqlQuProcedureInvocation);
  3462.     DDX_Check(pDX, IDC_SQL_QU_TABLE_DEFINITION, m_bSqlQuTableDefinition);
  3463.     DDX_Check(pDX, IDC_SQL_SO_DYNAMIC, m_bSqlSoDynamic);
  3464.     DDX_Check(pDX, IDC_SQL_SO_FORWARD_ONLY, m_bSqlSoForwardOnly);
  3465.     DDX_Check(pDX, IDC_SQL_SO_KEYSET_DRIVEN, m_bSqlSoKeysetDriven);
  3466.     DDX_Check(pDX, IDC_SQL_SO_MIXED, m_bSqlSoMixed);
  3467.     DDX_Check(pDX, IDC_SQL_SO_STATIC, m_bSqlSoStatic);
  3468.     DDX_Check(pDX, IDC_SQL_SCCO_LOCK, m_bSqlSccoLock);
  3469.     DDX_Check(pDX, IDC_SQL_SCCO_OPT_ROWVER, m_bSqlSccoOptRowver);
  3470.     DDX_Check(pDX, IDC_SQL_SCCO_OPT_VALUES, m_bSqlSccoOptValues);
  3471.     DDX_Check(pDX, IDC_SQL_SCCO_READ_ONLY, m_bSqlSccoReadOnly);
  3472.     DDX_Check(pDX, IDC_SQL_POS_ADD, m_bSqlPosAdd);
  3473.     DDX_Check(pDX, IDC_SQL_POS_DELETE, m_bSqlPosDelete);
  3474.     DDX_Check(pDX, IDC_SQL_POS_POSITION, m_bSqlPosPosition);
  3475.     DDX_Check(pDX, IDC_SQL_POS_REFRESH, m_bSqlPosRefresh);
  3476.     DDX_Check(pDX, IDC_SQL_POS_UPDATE, m_bSqlPosUpdate);
  3477.     DDX_Check(pDX, IDC_SQL_FD_FETCH_ABSOLUTE, m_bSqlFdFetchAbsolute);
  3478.     DDX_Check(pDX, IDC_SQL_FD_FETCH_BOOKMARK, m_bSqlFdFetchBookmark);
  3479.     DDX_Check(pDX, IDC_SQL_FD_FETCH_FIRST, m_bSqlFdFetchFirst);
  3480.     DDX_Check(pDX, IDC_SQL_FD_FETCH_LAST, m_bSqlFdFetchLast);
  3481.     DDX_Check(pDX, IDC_SQL_FD_FETCH_NEXT, m_bSqlFdFetchNext);
  3482.     DDX_Check(pDX, IDC_SQL_FD_FETCH_PRIOR, m_bSqlFdFetchPrior);
  3483.     DDX_Check(pDX, IDC_SQL_FD_FETCH_RELATIVE, m_bSqlFdFetchRelative);
  3484.     DDX_Check(pDX, IDC_SQL_FD_FETCH_RESUME, m_bSqlFdFetchResume);
  3485.     DDX_Check(pDX, IDC_SQL_GD_ANY_COLUMN, m_bSqlGdAnyColumn);
  3486.     DDX_Check(pDX, IDC_SQL_GD_ANY_ORDER, m_bSqlGdAnyOrder);
  3487.     DDX_Check(pDX, IDC_SQL_GD_BLOCK, m_bSqlGdBlock);
  3488.     DDX_Check(pDX, IDC_SQL_GD_BOUND, m_bSqlGdBound);
  3489.     DDX_Text(pDX, IDC_SQL_CONCAT_NULL_BEHAVIOR, m_strSqlConcatNullBehavior);
  3490.     DDX_Text(pDX, IDC_SQL_NEED_LONG_DATA_LEN, m_strSqlNeedLongDataLen);
  3491.     DDX_Text(pDX, IDC_SQL_NON_NULLABLE_COLUMNS, m_strSqlNonNullableColumns);
  3492.     DDX_Text(pDX, IDC_SQL_NULL_COLLATION, m_strSqlNullCollation);
  3493.     DDX_Text(pDX, IDC_SQL_PROCEDURES, m_strSqlProcedures);
  3494.     DDX_Text(pDX, IDC_SQL_ROW_UPDATES, m_strSqlRowUpdates);
  3495.     //}}AFX_DATA_MAP
  3496. }
  3497.  
  3498.  
  3499. BEGIN_MESSAGE_MAP(CMisc2, CPropertyPage)
  3500.     //{{AFX_MSG_MAP(CMisc2)
  3501.     //}}AFX_MSG_MAP
  3502. END_MESSAGE_MAP()
  3503.  
  3504. /////////////////////////////////////////////////////////////////////////////
  3505. // CMisc2 message handlers
  3506.  
  3507. void CMisc2::OnNewDSN()
  3508. {
  3509.     if (m_pDatabase->IsOpen())
  3510.     {
  3511.         SDWORD    longValue;
  3512.  
  3513.         YIsYes(m_strSqlNeedLongDataLen,SQL_NEED_LONG_DATA_LEN);
  3514.         switch (SQLGetInfoShort(SQL_NON_NULLABLE_COLUMNS))
  3515.         {
  3516.         case SQL_NNC_NULL:
  3517.             m_strSqlNonNullableColumns = _T("Not Supported");
  3518.             break;
  3519.         case SQL_NNC_NON_NULL:
  3520.             m_strSqlNonNullableColumns = _T("Supported");
  3521.             break;
  3522.         }
  3523.         switch (SQLGetInfoShort(SQL_CONCAT_NULL_BEHAVIOR))
  3524.         {
  3525.         case SQL_CB_NULL:
  3526.             m_strSqlConcatNullBehavior = _T("Result is NULL");
  3527.             break;
  3528.         case SQL_CB_NON_NULL:
  3529.             m_strSqlConcatNullBehavior = _T("Result is not NULL");
  3530.             break;
  3531.         }
  3532.         switch (SQLGetInfoShort(SQL_NULL_COLLATION))
  3533.         {
  3534.         case SQL_NC_END:
  3535.             m_strSqlNullCollation = _T("End");
  3536.             break;
  3537.         case SQL_NC_HIGH:
  3538.             m_strSqlNullCollation = _T("High");
  3539.             break;
  3540.         case SQL_NC_LOW:
  3541.             m_strSqlNullCollation = _T("Low");
  3542.             break;
  3543.         case SQL_NC_START:
  3544.             m_strSqlNullCollation = _T("Start");
  3545.             break;
  3546.         }
  3547.         YIsSupported(m_strSqlProcedures,SQL_PROCEDURES);
  3548.         YIsYes(m_strSqlRowUpdates,SQL_ROW_UPDATES);
  3549.         longValue = SQLGetInfoLong(SQL_FETCH_DIRECTION);
  3550.         if (longValue & SQL_FD_FETCH_NEXT)
  3551.             m_bSqlFdFetchNext = TRUE;
  3552.         else
  3553.             m_bSqlFdFetchNext = FALSE;
  3554.         if (longValue & SQL_FD_FETCH_FIRST)
  3555.             m_bSqlFdFetchFirst = TRUE;
  3556.         else
  3557.             m_bSqlFdFetchFirst = FALSE;
  3558.         if (longValue & SQL_FD_FETCH_LAST)
  3559.             m_bSqlFdFetchLast = TRUE;
  3560.         else
  3561.             m_bSqlFdFetchLast = FALSE;
  3562.         if (longValue & SQL_FD_FETCH_PRIOR)
  3563.             m_bSqlFdFetchPrior = TRUE;
  3564.         else
  3565.             m_bSqlFdFetchPrior = FALSE;
  3566.         if (longValue & SQL_FD_FETCH_ABSOLUTE)
  3567.             m_bSqlFdFetchAbsolute = TRUE;
  3568.         else
  3569.             m_bSqlFdFetchAbsolute = FALSE;
  3570.         if (longValue & SQL_FD_FETCH_RELATIVE)
  3571.             m_bSqlFdFetchRelative = TRUE;
  3572.         else
  3573.             m_bSqlFdFetchRelative = FALSE;
  3574.         if (longValue & SQL_FD_FETCH_RESUME)
  3575.             m_bSqlFdFetchResume = TRUE;
  3576.         else
  3577.             m_bSqlFdFetchResume = FALSE;
  3578.         if (longValue & SQL_FD_FETCH_BOOKMARK)
  3579.             m_bSqlFdFetchBookmark = TRUE;
  3580.         else
  3581.             m_bSqlFdFetchBookmark = FALSE;
  3582.  
  3583.         longValue = SQLGetInfoLong(SQL_GETDATA_EXTENSIONS);
  3584.         if (longValue & SQL_GD_ANY_COLUMN)
  3585.             m_bSqlGdAnyColumn = TRUE;
  3586.         else
  3587.             m_bSqlGdAnyColumn = FALSE;
  3588.         if (longValue & SQL_GD_ANY_ORDER)
  3589.             m_bSqlGdAnyOrder = TRUE;
  3590.         else
  3591.             m_bSqlGdAnyOrder = FALSE;
  3592.         if (longValue & SQL_GD_BLOCK)
  3593.             m_bSqlGdBlock = TRUE;
  3594.         else
  3595.             m_bSqlGdBlock = FALSE;
  3596.         if (longValue & SQL_GD_BOUND)
  3597.             m_bSqlGdBound = TRUE;
  3598.         else
  3599.             m_bSqlGdBound = FALSE;
  3600.  
  3601.         longValue = SQLGetInfoLong(SQL_POS_OPERATIONS);
  3602.         if (longValue & SQL_POS_POSITION)
  3603.             m_bSqlPosPosition = TRUE;
  3604.         else
  3605.             m_bSqlPosPosition = FALSE;
  3606.         if (longValue & SQL_POS_REFRESH)
  3607.             m_bSqlPosRefresh = TRUE;
  3608.         else
  3609.             m_bSqlPosRefresh = FALSE;
  3610.         if (longValue & SQL_POS_UPDATE)
  3611.             m_bSqlPosUpdate = TRUE;
  3612.         else
  3613.             m_bSqlPosUpdate = FALSE;
  3614.         if (longValue & SQL_POS_DELETE)
  3615.             m_bSqlPosDelete = TRUE;
  3616.         else
  3617.             m_bSqlPosDelete = FALSE;
  3618.         if (longValue & SQL_POS_ADD)
  3619.             m_bSqlPosAdd = TRUE;
  3620.         else
  3621.             m_bSqlPosAdd = FALSE;
  3622.  
  3623.         longValue = SQLGetInfoLong(SQL_SCROLL_CONCURRENCY);
  3624.         if (longValue & SQL_SCCO_READ_ONLY)
  3625.             m_bSqlSccoReadOnly = TRUE;
  3626.         else
  3627.             m_bSqlSccoReadOnly = FALSE;
  3628.         if (longValue & SQL_SCCO_LOCK)
  3629.             m_bSqlSccoLock = TRUE;
  3630.         else
  3631.             m_bSqlSccoLock = FALSE;
  3632.         if (longValue & SQL_SCCO_OPT_ROWVER)
  3633.             m_bSqlSccoOptRowver = TRUE;
  3634.         else
  3635.             m_bSqlSccoOptRowver = FALSE;
  3636.         if (longValue & SQL_SCCO_OPT_VALUES)
  3637.             m_bSqlSccoOptValues = TRUE;
  3638.         else
  3639.             m_bSqlSccoOptValues = FALSE;
  3640.         
  3641.         longValue = SQLGetInfoLong(SQL_SCROLL_OPTIONS);
  3642.         if (longValue & SQL_SO_FORWARD_ONLY)
  3643.             m_bSqlSoForwardOnly = TRUE;
  3644.         else
  3645.             m_bSqlSoForwardOnly = FALSE;
  3646.         if (longValue & SQL_SO_STATIC)
  3647.             m_bSqlSoStatic = TRUE;
  3648.         else
  3649.             m_bSqlSoStatic = FALSE;
  3650.         if (longValue & SQL_SO_KEYSET_DRIVEN)
  3651.             m_bSqlSoKeysetDriven = TRUE;
  3652.         else
  3653.             m_bSqlSoKeysetDriven = FALSE;
  3654.         if (longValue & SQL_SO_DYNAMIC)
  3655.             m_bSqlSoDynamic = TRUE;
  3656.         else
  3657.             m_bSqlSoDynamic = FALSE;
  3658.         if (longValue & SQL_SO_MIXED)
  3659.             m_bSqlSoMixed = TRUE;
  3660.         else
  3661.             m_bSqlSoMixed = FALSE;
  3662.  
  3663.         longValue = SQLGetInfoLong(SQL_OWNER_USAGE);
  3664.         if (longValue & SQL_OU_DML_STATEMENTS)
  3665.             m_bSqlOuDmlStatements = TRUE;
  3666.         else
  3667.             m_bSqlOuDmlStatements = FALSE;
  3668.         if (longValue & SQL_OU_PROCEDURE_INVOCATION)
  3669.             m_bSqlOuProcedureInvocation = TRUE;
  3670.         else
  3671.             m_bSqlOuProcedureInvocation = FALSE;
  3672.         if (longValue & SQL_OU_TABLE_DEFINITION)
  3673.             m_bSqlOuTableDefinition = TRUE;
  3674.         else
  3675.             m_bSqlOuTableDefinition = FALSE;
  3676.         if (longValue & SQL_OU_INDEX_DEFINITION)
  3677.             m_bSqlOuIndexDefinition = TRUE;
  3678.         else
  3679.             m_bSqlOuIndexDefinition = FALSE;
  3680.         if (longValue & SQL_OU_PRIVILEGE_DEFINITION)
  3681.             m_bSqlOuPrivilegeDefinition = TRUE;
  3682.         else
  3683.             m_bSqlOuPrivilegeDefinition = FALSE;
  3684.  
  3685.         longValue = SQLGetInfoLong(SQL_QUALIFIER_USAGE);
  3686.         if (longValue & SQL_QU_DML_STATEMENTS)
  3687.             m_bSqlQuDmlStatements = TRUE;
  3688.         else
  3689.             m_bSqlQuDmlStatements = FALSE;
  3690.         if (longValue & SQL_QU_PROCEDURE_INVOCATION)
  3691.             m_bSqlQuProcedureInvocation = TRUE;
  3692.         else
  3693.             m_bSqlQuProcedureInvocation = FALSE;
  3694.         if (longValue & SQL_QU_TABLE_DEFINITION)
  3695.             m_bSqlQuTableDefinition = TRUE;
  3696.         else
  3697.             m_bSqlQuTableDefinition = FALSE;
  3698.         if (longValue & SQL_QU_INDEX_DEFINITION)
  3699.             m_bSqlQuIndexDefinition = TRUE;
  3700.         else
  3701.             m_bSqlQuIndexDefinition = FALSE;
  3702.         if (longValue & SQL_QU_PRIVILEGE_DEFINITION)
  3703.             m_bSqlQuPrivilegeDefinition = TRUE;
  3704.         else
  3705.             m_bSqlQuPrivilegeDefinition = FALSE;
  3706.  
  3707.         if (IsWindow(m_hWnd))
  3708.             UpdateData(FALSE);
  3709.     }
  3710. }
  3711.  
  3712. BOOL CMisc2::OnInitDialog() 
  3713. {
  3714.     CPropertyPage::OnInitDialog();
  3715.     
  3716.     UpdateData(FALSE);
  3717.     
  3718.     return TRUE;  // return TRUE unless you set the focus to a control
  3719.                   // EXCEPTION: OCX Property Pages should return FALSE
  3720. }
  3721.